2074 lines
55 KiB
Plaintext
2074 lines
55 KiB
Plaintext
AdventureDataProxy = class('AdventureDataProxy', pm.Proxy)
|
||
AdventureDataProxy.Instance = nil;
|
||
AdventureDataProxy.NAME = "AdventureDataProxy"
|
||
autoImport('AdventureBagData')
|
||
autoImport('AdventureCollectionGroupData')
|
||
autoImport("WholeQuestData")
|
||
autoImport("Table_ItemBeTransformedWay")
|
||
autoImport("Table_AdventureValue")
|
||
autoImport("Table_AdventureItem")
|
||
|
||
autoImport ("PersonalPictureManager")
|
||
autoImport ("MySceneryPictureManager")
|
||
|
||
AdventureDataProxy.Instance = nil;
|
||
AdventureDataProxy.InitBag = {
|
||
SceneManual_pb.EMANUALTYPE_FASHION,
|
||
SceneManual_pb.EMANUALTYPE_CARD,
|
||
SceneManual_pb.EMANUALTYPE_EQUIP,
|
||
SceneManual_pb.EMANUALTYPE_ITEM,
|
||
SceneManual_pb.EMANUALTYPE_MOUNT,
|
||
SceneManual_pb.EMANUALTYPE_MONSTER,
|
||
SceneManual_pb.EMANUALTYPE_NPC,
|
||
SceneManual_pb.EMANUALTYPE_MAP,
|
||
SceneManual_pb.EMANUALTYPE_ACHIEVE,
|
||
SceneManual_pb.EMANUALTYPE_SCENERY,
|
||
SceneManual_pb.EMANUALTYPE_COLLECTION,
|
||
SceneManual_pb.EMANUALTYPE_RESEARCH,
|
||
SceneManual_pb.EMANUALTYPE_HAIRSTYLE,
|
||
SceneManual_pb.EMANUALTYPE_PET,
|
||
SceneManual_pb.EMANUALTYPE_MATE,
|
||
}
|
||
|
||
AdventureDataProxy.NoServerSyncType = {
|
||
SceneManual_pb.EMANUALTYPE_EQUIP,
|
||
SceneManual_pb.EMANUALTYPE_HAIRSTYLE,
|
||
SceneManual_pb.EMANUALTYPE_ITEM,
|
||
}
|
||
|
||
AdventureDataProxy.DeathDrop = {
|
||
SceneManual_pb.EMANUALTYPE_CARD,
|
||
SceneManual_pb.EMANUALTYPE_FASHION,
|
||
SceneManual_pb.EMANUALTYPE_EQUIP,
|
||
SceneManual_pb.EMANUALTYPE_ITEM,
|
||
SceneManual_pb.EMANUALTYPE_MOUNT,
|
||
SceneManual_pb.EMANUALTYPE_COLLECTION,
|
||
}
|
||
|
||
AdventureDataProxy.FilterPropType = {
|
||
"AttrChange",
|
||
"AddBuff",
|
||
"BattleAttr",
|
||
"ChangeScale",
|
||
"ForceAttr",
|
||
"ImmuneStatus",
|
||
"ResistStatus",
|
||
"StatusChange",
|
||
"HSPChange"
|
||
}
|
||
|
||
AdventureDataProxy.FilterSkillType = {
|
||
"AffactSkill",
|
||
"DeepHide",
|
||
"AddSkillCD",
|
||
"BuffSpeedUp",
|
||
"DelSkillStatus",
|
||
"GetSkill",
|
||
"ReplaceSkill",
|
||
"UseSkill"
|
||
}
|
||
|
||
AdventureDataProxy.MonthCardTabId = 1052
|
||
|
||
local tempArrayData = {}
|
||
function AdventureDataProxy:ctor(proxyName, data)
|
||
self.proxyName = proxyName or AdventureDataProxy.NAME
|
||
if(AdventureDataProxy.Instance == nil) then
|
||
AdventureDataProxy.Instance = self
|
||
end
|
||
|
||
if data ~= nil then
|
||
self:setData(data)
|
||
end
|
||
self:initTableItemTypeAdventure()
|
||
self.bagMap = {}
|
||
|
||
self.NpcCount = 0
|
||
-- for k,v in pairs(Table_Npc) do
|
||
-- if(v.AdventureValue and v.AdventureValue >0)then
|
||
-- self.NpcCount = self.NpcCount +1
|
||
-- end
|
||
-- end
|
||
self.NpcCount = Table_AdventureValue["npc"].count
|
||
|
||
for k,v in pairs(AdventureDataProxy.InitBag) do
|
||
local bagData = AdventureBagData.new(nil,v)
|
||
self.bagMap[v] = bagData
|
||
end
|
||
|
||
self.finishGenThumbnail = true
|
||
self.tobeGenList = {}
|
||
self.collectionGroupDatas = {}
|
||
self.tempScenerys = {}
|
||
self.tempAlbumTime = 0
|
||
self:initBagData()
|
||
|
||
self.hasCountNpsDeathDrop = {}
|
||
self.hasCountNps = {}
|
||
self.hasCountMap = {}
|
||
self.hasCountMenu = {}
|
||
self.hasCountCollection = {}
|
||
self.adventurePropClassify = {}
|
||
self.fashionGroupData = {}
|
||
self.propTypeDatas = {}
|
||
|
||
self:initFashionGroupData()
|
||
|
||
-- self:Test()
|
||
end
|
||
|
||
local tempTable = {}
|
||
|
||
|
||
function AdventureDataProxy:initFashionGroupData( )
|
||
TableUtility.ArrayClear(self.fashionGroupData)
|
||
for k,v in pairs(Table_Equip) do
|
||
if(v.GroupID and not v.GroupID ~= k)then
|
||
local tb = self.fashionGroupData[v.GroupID] or {}
|
||
tb[#tb+1] = v
|
||
self.fashionGroupData[v.GroupID] = tb
|
||
end
|
||
end
|
||
|
||
for k,v in pairs(self.fashionGroupData) do
|
||
table.sort(v,function (l,r )
|
||
-- body
|
||
return l.id<r.id
|
||
end)
|
||
end
|
||
end
|
||
|
||
|
||
function AdventureDataProxy:initBagData( )
|
||
-- body
|
||
for i=1,#Table_AdventureItem do
|
||
local id = Table_AdventureItem[i]
|
||
tempTable.id = id
|
||
tempTable.status = SceneManual_pb.EMANUALSTATUS_DISPLAY
|
||
for i=1,#AdventureDataProxy.NoServerSyncType do
|
||
local type = AdventureDataProxy.NoServerSyncType[i]
|
||
local item = AdventureItemData.new(tempTable,type)
|
||
local bagData = self.bagMap[type]
|
||
local tab = bagData:getTabByItemAndType(item,type)
|
||
if(tab and tab.tab.id ~= AdventureDataProxy.MonthCardTabId)then
|
||
-- if(tab )then
|
||
-- helplog("initBagData:tabId:",tab.tab.id,item.staticData.NameZh)
|
||
bagData:AddItem(item,type)
|
||
break
|
||
end
|
||
end
|
||
end
|
||
-- for k,v in pairs(Table_Item) do
|
||
-- if(v.AdventureValue == -1)then
|
||
-- tempTable.id = v.id
|
||
-- tempTable.status = SceneManual_pb.EMANUALSTATUS_DISPLAY
|
||
-- for i=1,#AdventureDataProxy.NoServerSyncType do
|
||
-- local type = AdventureDataProxy.NoServerSyncType[i]
|
||
-- local item = AdventureItemData.new(tempTable,type)
|
||
-- local bagData = self.bagMap[type]
|
||
-- local tab = bagData:getTabByItemAndType(item,type)
|
||
-- if(tab and tab.tab.id ~= AdventureDataProxy.MonthCardTabId)then
|
||
-- -- if(tab )then
|
||
-- -- helplog("initBagData:tabId:",tab.tab.id,item.staticData.NameZh)
|
||
-- bagData:AddItem(item,type)
|
||
-- break
|
||
-- end
|
||
-- end
|
||
-- end
|
||
-- end
|
||
for k,v in pairs(Table_MercenaryCat) do
|
||
if(v.AdventureValue == -1 and v.MonsterID)then
|
||
tempTable.id = v.MonsterID
|
||
tempTable.status = SceneManual_pb.EMANUALSTATUS_DISPLAY
|
||
local type = SceneManual_pb.EMANUALTYPE_MATE
|
||
local item = AdventureItemData.new(tempTable,type)
|
||
item:setCatId(v.id)
|
||
local bagData = self.bagMap[type]
|
||
local tab = bagData:getTabByItemAndType(item,type)
|
||
if(tab)then
|
||
bagData:AddItem(item,type)
|
||
end
|
||
end
|
||
end
|
||
|
||
for k,v in pairs(Table_Collection) do
|
||
local groupData = AdventureCollectionGroupData.new(k)
|
||
self.collectionGroupDatas[#self.collectionGroupDatas+1] = groupData
|
||
for i=1,#v.ItemId do
|
||
local single = v.ItemId[i]
|
||
local type = SceneManual_pb.EMANUALTYPE_COLLECTION
|
||
local bagData = self.bagMap[type]
|
||
local oldItem = bagData:GetItemByStaticID(single)
|
||
if(oldItem)then
|
||
oldItem:setCollectionGroupId(v.GroupID)
|
||
else
|
||
tempTable.id = single
|
||
tempTable.status = SceneManual_pb.EMANUALSTATUS_DISPLAY
|
||
local item = AdventureItemData.new(tempTable,type)
|
||
item:setCollectionGroupId(k)
|
||
local tab = bagData:getTabByItemAndType(item,type)
|
||
if(tab)then
|
||
bagData:AddItem(item,type)
|
||
groupData:addCollectionData(item)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
local tb = GameConfig.Pet.cancel_special_effects or {}
|
||
|
||
for k,v in pairs(Table_Pet) do
|
||
if(TableUtility.ArrayFindIndex(tb,v.id) == 0)then
|
||
tempTable.id = v.id
|
||
tempTable.status = SceneManual_pb.EMANUALSTATUS_DISPLAY
|
||
local type = SceneManual_pb.EMANUALTYPE_PET
|
||
local item = AdventureItemData.new(tempTable,type)
|
||
local bagData = self.bagMap[type]
|
||
local tab = bagData:getTabByItemAndType(item,type)
|
||
if(tab)then
|
||
bagData:AddItem(item,type)
|
||
end
|
||
end
|
||
end
|
||
|
||
end
|
||
|
||
function AdventureDataProxy:initTableItemTypeAdventure()
|
||
self.categoryDatas = {}
|
||
|
||
-- local itemType = {unpack(Table_ItemType)}
|
||
|
||
-- local tableAdventure = {unpack(Table_ItemTypeAdventureLog)}
|
||
-- TableUtil.Print(tableAdventure)
|
||
self.categoryDatas[SceneManual_pb.EMANUALTYPE_HOMEPAGE] = {staticData = Table_ItemTypeAdventureLog[SceneManual_pb.EMANUALTYPE_HOMEPAGE]}
|
||
|
||
for k,v in pairs(Table_ItemTypeAdventureLog) do
|
||
-- printRed("log type:"..k)
|
||
|
||
-- print(v.type)
|
||
if(v.type)then
|
||
local categorys = self.categoryDatas[v.type] or { staticData = Table_ItemTypeAdventureLog[v.type] }
|
||
local childs = categorys.childs or {}
|
||
local child = childs[k] or {staticData = v }
|
||
local types = child.types or {}
|
||
for k1,v1 in pairs(Table_ItemType) do
|
||
-- printRed(k1,v1)
|
||
if(v1.AdventureLogGroup and v1.AdventureLogGroup == k)then
|
||
table.insert(types,v1.id)
|
||
end
|
||
end
|
||
child.types = types
|
||
childs[k] = child
|
||
categorys.childs = childs
|
||
self.categoryDatas[v.type] = categorys
|
||
end
|
||
|
||
if(v.Classify)then
|
||
local classifyData = Table_ItemTypeAdventureLog[v.Classify]
|
||
if(classifyData)then
|
||
local categorys = self.categoryDatas[classifyData.type] or { staticData = Table_ItemTypeAdventureLog[classifyData.type] }
|
||
local childs = categorys.childs or {}
|
||
local child = childs[classifyData.id] or {staticData = classifyData }
|
||
local classifys = child.classifys or {}
|
||
table.insert(classifys,v)
|
||
child.classifys = classifys
|
||
childs[classifyData.id] = child
|
||
categorys.childs = childs
|
||
self.categoryDatas[classifyData.type] = categorys
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:GetCollectionGroup(groupId)
|
||
for i=1,#self.collectionGroupDatas do
|
||
local single = self.collectionGroupDatas[i]
|
||
if(single.staticId == groupId)then
|
||
return single
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:GetAllCollectionGroups( )
|
||
-- body
|
||
return self.collectionGroupDatas
|
||
end
|
||
|
||
function AdventureDataProxy:GetAllUnlockCollectionGroups( )
|
||
-- body
|
||
local list = {}
|
||
for i=1,#self.collectionGroupDatas do
|
||
local single = self.collectionGroupDatas[i]
|
||
if(single:IsUnlock())then
|
||
list[#list +1] = single
|
||
end
|
||
end
|
||
return list
|
||
end
|
||
|
||
function AdventureDataProxy:GetCollectionsByGroup(groupId)
|
||
local groupData = self:GetCollectionGroup(groupId)
|
||
if(groupData)then
|
||
return groupData.collections
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:CheckItemIsCollection(itemdata)
|
||
local bagData = self.bagMap[SceneManual_pb.EMANUALTYPE_COLLECTION];
|
||
if(bagData)then
|
||
local tab = bagData:getTabByItemAndType(itemdata, SceneManual_pb.EMANUALTYPE_COLLECTION)
|
||
if(tab~=nil)then
|
||
return true;
|
||
end
|
||
end
|
||
return false;
|
||
end
|
||
|
||
function AdventureDataProxy:NewMapAdd( mapId )
|
||
-- body
|
||
--TODO
|
||
-- self.hasCountMap[mapId] = true
|
||
if(self.hasCountMap[mapId])then
|
||
return
|
||
end
|
||
self.hasCountMap[mapId] = true
|
||
local mapData = Table_Map[mapId]
|
||
if(mapData)then
|
||
self:NewCollectionAdd(mapId)
|
||
local sceneName = mapData.NameEn
|
||
local sceneInfo = autoImport("Scene_"..sceneName)
|
||
local scenePartInfo = nil
|
||
if sceneInfo and sceneInfo.PVE then
|
||
scenePartInfo = sceneInfo.PVE
|
||
if scenePartInfo and scenePartInfo.nps and #scenePartInfo.nps>0 then
|
||
local nps = scenePartInfo.nps
|
||
for i=1,#nps do
|
||
local npcId = nps[i].ID
|
||
-- helplog("NewMapAdd:",mapId,npcId)
|
||
self:NewMonsterAdd(npcId)
|
||
end
|
||
end
|
||
end
|
||
for k,v in pairs(Table_Boss) do
|
||
for i=1,#v.Map do
|
||
local single = v.Map[i]
|
||
if(mapId == single)then
|
||
self:NewMonsterAdd(k)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:NewMonsterAdd( monsterId )
|
||
if(self.hasCountNps[monsterId])then
|
||
return
|
||
end
|
||
self.hasCountNps[monsterId] = true
|
||
local type
|
||
local data
|
||
if(NpcMonsterUtility.IsMonsterByID(monsterId))then
|
||
type = SceneManual_pb.EMANUALTYPE_MONSTER
|
||
self:NewMonsterDeathDropAdd(monsterId)
|
||
data = Table_Monster[monsterId]
|
||
elseif(NpcMonsterUtility.IsNpcByID(monsterId))then
|
||
type = SceneManual_pb.EMANUALTYPE_NPC
|
||
data = Table_Npc[monsterId]
|
||
end
|
||
if(type and data and (data.AdventureValue and data.AdventureValue ~= 0))then
|
||
tempTable.id = monsterId
|
||
tempTable.status = SceneManual_pb.EMANUALSTATUS_DISPLAY
|
||
local item = AdventureItemData.new(tempTable,type)
|
||
local bagData = self.bagMap[type]
|
||
local tab = bagData:getTabByItemAndType(item,type)
|
||
local oldItem = bagData:GetItemByStaticID(monsterId)
|
||
if(tab and not oldItem)then
|
||
bagData:AddItem(item,type)
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:NewMonsterDeathDropAdd( monsterId )
|
||
-- body
|
||
if(self.hasCountNpsDeathDrop[monsterId])then
|
||
return
|
||
end
|
||
self.hasCountNpsDeathDrop[monsterId] = true
|
||
local items = ItemUtil.GetDeath_Drops(monsterId)
|
||
if(items and #items>0)then
|
||
for i=1,#items do
|
||
local itemData = items[i].itemData
|
||
if(itemData.AdventureValue and itemData.AdventureValue ~= 0)then
|
||
tempTable.id = itemData.id
|
||
tempTable.status = SceneManual_pb.EMANUALSTATUS_DISPLAY
|
||
for i=1,#AdventureDataProxy.DeathDrop do
|
||
local type = AdventureDataProxy.DeathDrop[i]
|
||
local item = AdventureItemData.new(tempTable,type)
|
||
local bagData = self.bagMap[type]
|
||
local tab = bagData:getTabByItemAndType(item,type)
|
||
local oldItem = bagData:GetItemByStaticID(itemData.id)
|
||
-- helplog("NewMonsterDeathDropAdd:",itemData.id,type,tostring(monsterId),tostring(tab.tab.id),tostring(oldItem))
|
||
-- helplog("NewMonsterDeathDropAdd:",itemData.NameZh)
|
||
if(tab and not oldItem)then
|
||
bagData:AddItem(item,type)
|
||
end
|
||
end
|
||
end
|
||
local productId = ItemUtil.GetComposeItemByBlueItem(itemData)
|
||
local productItem = Table_Item[productId]
|
||
if(productItem and productItem.AdventureValue and productItem.AdventureValue ~= 0)then
|
||
tempTable.id = productItem.id
|
||
tempTable.status = SceneManual_pb.EMANUALSTATUS_DISPLAY
|
||
for i=1,#AdventureDataProxy.DeathDrop do
|
||
local type = AdventureDataProxy.DeathDrop[i]
|
||
local item = AdventureItemData.new(tempTable,type)
|
||
local bagData = self.bagMap[type]
|
||
local tab = bagData:getTabByItemAndType(item,type)
|
||
local oldItem = bagData:GetItemByStaticID(productItem.id)
|
||
-- helplog("NewMonsterDeathDropAdd productItem:",productItem.id,type,tostring(monsterId),tostring(tab),tostring(oldItem))
|
||
-- helplog("NewMonsterDeathDropAdd productItem:",productItem.NameZh)
|
||
if(tab and not oldItem)then
|
||
bagData:AddItem(item,type)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:NewMenusAdd( menuIds )
|
||
-- body
|
||
if(menuIds and #menuIds>0)then
|
||
for i=1,#menuIds do
|
||
self:NewMenuAdd(menuIds[i])
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:NewMenuAdd( menuId )
|
||
-- body
|
||
-- helplog("NewMenuAdd:",menuId)
|
||
-- self.hasCountMenu[menuId] = true
|
||
if(self.hasCountMenu[menuId])then
|
||
return
|
||
end
|
||
self.hasCountMenu[menuId] = true
|
||
local menuData = Table_Menu[menuId]
|
||
if(menuData)then
|
||
local eventType = menuData.event.type
|
||
-- helplog("NewMenuAdd:",menuId,eventType)
|
||
if(eventType and eventType == "unlockmanual")then
|
||
if(menuData.event.param and menuData.event.param[1] == SceneManual_pb.EMANUALTYPE_MONSTER)then
|
||
for i=2,#menuData.event.param do
|
||
-- helplog("NewMenuAdd:",tostring(menuData.event.param[i]))
|
||
self:NewMonsterAdd(menuData.event.param[i])
|
||
end
|
||
elseif(menuData.event.param and menuData.event.param[1] == SceneManual_pb.EMANUALTYPE_COLLECTION)then
|
||
for i=2,#menuData.event.param do
|
||
-- helplog("NewMenuAdd:",tostring(menuData.event.param[i]))
|
||
self:NewSingleCollectionAdd(menuData.event.param[i])
|
||
end
|
||
elseif(menuData.event.param and menuData.event.param[1] == SceneManual_pb.EMANUALTYPE_MAP)then
|
||
for i=2,#menuData.event.param do
|
||
self:NewCollectionAdd(menuData.event.param[i])
|
||
end
|
||
end
|
||
elseif(eventType and eventType == "scenery")then
|
||
for i=1,#menuData.event.param do
|
||
self:NewSceneryAdd(menuData.event.param[i])
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:NewSingleCollectionAdd( itemId )
|
||
local itemData = Table_Item[itemId]
|
||
if(itemData and itemData.AdventureValue and itemData.AdventureValue ~= 0)then
|
||
tempTable.id = itemId
|
||
tempTable.status = SceneManual_pb.EMANUALSTATUS_DISPLAY
|
||
local type = SceneManual_pb.EMANUALTYPE_COLLECTION
|
||
local item = AdventureItemData.new(tempTable,type)
|
||
local bagData = self.bagMap[type]
|
||
local tab = bagData:getTabByItemAndType(item,type)
|
||
local oldItem = bagData:GetItemByStaticID(itemId)
|
||
if(tab and not oldItem)then
|
||
bagData:AddItem(item,type)
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:NewCollectionAdd( collectionId )
|
||
if(self.hasCountCollection[collectionId])then
|
||
return
|
||
end
|
||
self.hasCountCollection[collectionId] = true
|
||
for i=1,#self.collectionGroupDatas do
|
||
local single = self.collectionGroupDatas[i]
|
||
if(single.staticData.mapID == collectionId)then
|
||
single:setUnlock(true)
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:NewSceneryAdd( sceneryId )
|
||
local sceneryData = Table_Viewspot[sceneryId]
|
||
if(sceneryData and sceneryData.AdventureValue and sceneryData.AdventureValue ~= 0)then
|
||
tempTable.id = sceneryId
|
||
tempTable.status = SceneManual_pb.EMANUALSTATUS_DISPLAY
|
||
local type = SceneManual_pb.EMANUALTYPE_SCENERY
|
||
local item = AdventureItemData.new(tempTable,type)
|
||
local bagData = self.bagMap[type]
|
||
local tab = bagData:getTabByItemAndType(item,type)
|
||
local oldItem = bagData:GetItemByStaticID(sceneryId)
|
||
if(tab and not oldItem)then
|
||
bagData:AddItem(item,type)
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:thumbCpCallback( data )
|
||
-- body
|
||
-- {baID = ba_id})
|
||
self:thumbnailCompleteCallback( data.baID,data.bytes )
|
||
end
|
||
|
||
function AdventureDataProxy:thumbPgCallback( data )
|
||
-- body
|
||
-- {baID = ba_id, progress = x}
|
||
self:thumbnailProgressCallback( data.baID,data.progress )
|
||
end
|
||
|
||
function AdventureDataProxy:onRegister()
|
||
end
|
||
|
||
function AdventureDataProxy:getRidTipsByCategoryId( id )
|
||
-- body
|
||
local redTipIds = {}
|
||
local categorys = AdventureDataProxy.Instance:getTabsByCategory(id)
|
||
if(categorys and categorys.childs)then
|
||
for k,v in pairs(categorys.childs) do
|
||
local redId = v.staticData.RidTip
|
||
if( redId and type(redId) == "number")then
|
||
table.insert(redTipIds,redId)
|
||
elseif( redId and type(redId) == "table")then
|
||
for i=1,#redId do
|
||
table.insert(redTipIds,redId[i])
|
||
end
|
||
end
|
||
end
|
||
end
|
||
return redTipIds
|
||
end
|
||
|
||
function AdventureDataProxy:checkSceneryRedTips(bagType )
|
||
-- body
|
||
for k1,v1 in pairs(self.categoryDatas) do
|
||
local categorys = v1
|
||
if(k1 ~= SceneManual_pb.EMANUALTYPE_ACHIEVE )then
|
||
if((bagType and bagType == k1) or bagType == nil )then
|
||
local bgData = self.bagMap[k1]
|
||
-- printRed(v1,k1)
|
||
if(categorys and categorys.childs and bgData)then
|
||
for k,v in pairs(categorys.childs) do
|
||
local redId = v.staticData.RidTip
|
||
if(redId)then
|
||
local list = bgData:GetItems(k)
|
||
local addRed = false
|
||
for i=1,#list do
|
||
local single = list[i]
|
||
local append = single:getCompleteNoRewardAppend()
|
||
if(#append > 0 or single.status == SceneManual_pb.EMANUALSTATUS_UNLOCK_CLIENT and not single:getCollectionGroupId())then
|
||
addRed = true
|
||
break
|
||
end
|
||
end
|
||
|
||
if(type(redId) == "number")then
|
||
if(addRed)then
|
||
RedTipProxy.Instance:UpdateRedTip(redId)
|
||
else
|
||
RedTipProxy.Instance:RemoveWholeTip(redId)
|
||
end
|
||
elseif(type(redId) == "table")then
|
||
for i=1,#redId do
|
||
if(addRed)then
|
||
RedTipProxy.Instance:UpdateRedTip(redId[i])
|
||
else
|
||
RedTipProxy.Instance:RemoveWholeTip(redId[i])
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
if(bagType == SceneManual_pb.EMANUALTYPE_COLLECTION and bgData)then
|
||
self:checkCollectionRedTips()
|
||
end
|
||
if(bagType)then
|
||
break
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:checkCollectionRedTips( )
|
||
for i=1,#self.collectionGroupDatas do
|
||
local single = self.collectionGroupDatas[i]
|
||
local hasRed = single:hasToBeUnlockItem()
|
||
|
||
if(not single:IsUnlock() and not single:isTotalUnComplete())then
|
||
single:setUnlock(true)
|
||
end
|
||
if hasRed then
|
||
RedTipProxy.Instance:UpdateRedTip(single.staticData.RedTip)
|
||
else
|
||
RedTipProxy.Instance:RemoveWholeTip(single.staticData.RedTip)
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:checkFoodRedTips( )
|
||
-- body
|
||
local food_cook_info = FoodProxy.Instance.food_cook_info
|
||
|
||
local notifySv = true
|
||
for k,v in pairs(food_cook_info) do
|
||
local AdventureValue = v.itemData.staticData and v.itemData.staticData.AdventureValue
|
||
if(v.status == SceneFood_pb.EFOODSTATUS_ADD and AdventureValue and AdventureValue ~=0 )then
|
||
notifySv = false
|
||
RedTipProxy.Instance:UpdateRedTip(38)
|
||
break
|
||
end
|
||
end
|
||
if(notifySv)then
|
||
RedTipProxy.Instance:RemoveWholeTip(38)
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:getTabsByCategory(categoryId)
|
||
-- printRed("categoryId"..categoryId)
|
||
-- print(self.categoryDatas[categoryId].child)
|
||
return self.categoryDatas[categoryId]
|
||
end
|
||
|
||
function AdventureDataProxy:isCard( type )
|
||
-- body
|
||
local categorys = self.categoryDatas[SceneManual_pb.EMANUALTYPE_CARD]
|
||
if(categorys and categorys.childs)then
|
||
for k,v in pairs(categorys.childs) do
|
||
for i=1,#v.types do
|
||
local single = v.types[i]
|
||
if(type == single )then
|
||
return true
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:hasUnlockCard( Quality,cardType )
|
||
-- body
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_CARD]
|
||
if(bgData)then
|
||
local list = bgData:GetItems()
|
||
for i=1,#list do
|
||
local single = list[i]
|
||
if(single.staticData and single.staticData.Quality == Quality and
|
||
single.status == SceneManual_pb.EMANUALSTATUS_DISPLAY and
|
||
single.cardInfo.CardType == cardType)then
|
||
return true
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:onRemove()
|
||
|
||
end
|
||
|
||
function AdventureDataProxy:SetIsNewFlag(package,value)
|
||
local bag = self.bagMap[package]
|
||
local items = bag:GetItems()
|
||
for i=1,#items do
|
||
items[i].isNew = value
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:setPointData( value )
|
||
-- body
|
||
self.totalData = value
|
||
end
|
||
|
||
function AdventureDataProxy:getPointData( )
|
||
-- body
|
||
return self.totalData or 0
|
||
end
|
||
|
||
function AdventureDataProxy:setSkillPoint(value)
|
||
self.skillPoint = value
|
||
end
|
||
|
||
function AdventureDataProxy:getSkillPoint(value)
|
||
return self.skillPoint or 0
|
||
end
|
||
|
||
function AdventureDataProxy:setManualLevel( value )
|
||
-- body
|
||
-- printRed("setManualLevel",value)
|
||
local cur = self:getManualLevel()
|
||
self.manualLevel = value
|
||
if(cur<value)then
|
||
GameFacade.Instance:sendNotification(SceneUserEvent.LevelUp, self,SceneUserEvent.ManualLevelUp)
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:getManualLevel( )
|
||
-- body
|
||
return self.manualLevel or 1
|
||
end
|
||
|
||
function AdventureDataProxy:IsNpcUnlock( npcId )
|
||
-- body
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_NPC]
|
||
if(bgData)then
|
||
local npcData = bgData:GetItemByStaticID(npcId)
|
||
if(npcData)then
|
||
return npcData.status == SceneManual_pb.EMANUALSTATUS_UNLOCK
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:IsSceneryUnlock( sceneryId )
|
||
-- body
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_SCENERY]
|
||
if(bgData)then
|
||
local data = bgData:GetItemByStaticID(sceneryId)
|
||
if(data)then
|
||
return data.status == SceneManual_pb.EMANUALSTATUS_UNLOCK
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:IsFashionUnlock( itemId )
|
||
-- body
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_FASHION]
|
||
if(bgData)then
|
||
local data = bgData:GetItemByStaticID(itemId)
|
||
if(data)then
|
||
return data.status == SceneManual_pb.EMANUALSTATUS_UNLOCK
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:IsFashionStored( itemId )
|
||
-- body
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_FASHION]
|
||
if(bgData)then
|
||
local data = bgData:GetItemByStaticID(itemId)
|
||
if(data)then
|
||
return data.store
|
||
end
|
||
end
|
||
end
|
||
|
||
----------布点作品坐骑
|
||
function AdventureDataProxy:IsMountUnlock( itemId )
|
||
-- body
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_MOUNT]
|
||
if(bgData)then
|
||
local data = bgData:GetItemByStaticID(itemId)
|
||
if(data)then
|
||
return data.status == SceneManual_pb.EMANUALSTATUS_UNLOCK
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:IsMountStored( itemId )
|
||
-- body
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_MOUNT]
|
||
if(bgData)then
|
||
local data = bgData:GetItemByStaticID(itemId)
|
||
if(data)then
|
||
return data.store
|
||
end
|
||
end
|
||
end
|
||
|
||
|
||
|
||
|
||
function AdventureDataProxy:IsCardUnlock( itemId )
|
||
-- body
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_CARD]
|
||
if(bgData)then
|
||
local data = bgData:GetItemByStaticID(itemId)
|
||
if(data)then
|
||
return data.status == SceneManual_pb.EMANUALSTATUS_UNLOCK
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:IsCardStored( itemId )
|
||
-- body
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_CARD]
|
||
if(bgData)then
|
||
local data = bgData:GetItemByStaticID(itemId)
|
||
if(data)then
|
||
return data.store
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:GetSceneryData( sceneryId )
|
||
-- body
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_SCENERY]
|
||
if(bgData)then
|
||
return bgData:GetItemByStaticID(sceneryId)
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:IsSceneryHasTakePic( sceneryId )
|
||
-- body
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_SCENERY]
|
||
if(bgData)then
|
||
local data = bgData:GetItemByStaticID(sceneryId)
|
||
if(data)then
|
||
return data.status ~= SceneManual_pb.EMANUALSTATUS_DISPLAY
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:IsSceneryDisplay( sceneryId )
|
||
-- body
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_SCENERY]
|
||
if(bgData)then
|
||
local data = bgData:GetItemByStaticID(sceneryId)
|
||
if(data)then
|
||
return data.status == SceneManual_pb.EMANUALSTATUS_DISPLAY
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:IsSceneryUpload( sceneryId )
|
||
-- body
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_SCENERY]
|
||
if(bgData)then
|
||
local data = bgData:GetItemByStaticID(sceneryId)
|
||
if(data)then
|
||
return data.attrUnlock
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:IsCollectionGained( collectionId )
|
||
-- body
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_COLLECTION]
|
||
if(bgData)then
|
||
local data = bgData:GetItemByStaticID(collectionId)
|
||
if(data)then
|
||
return data.status ~= SceneManual_pb.EMANUALSTATUS_DISPLAY
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:getAllUploadedScenerys( )
|
||
-- body
|
||
local ret = {}
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_SCENERY]
|
||
if(bgData)then
|
||
local list = bgData:GetItems()
|
||
for i=1,#list do
|
||
local single = list[i]
|
||
if(single.attrUnlock)then
|
||
table.insert(ret,single)
|
||
end
|
||
end
|
||
end
|
||
return ret
|
||
end
|
||
|
||
function AdventureDataProxy:getCanAndHasUnlockedScenerys( )
|
||
-- body
|
||
local ret = {}
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_SCENERY]
|
||
if(bgData)then
|
||
local list = bgData:GetItems()
|
||
for i=1,#list do
|
||
local single = list[i]
|
||
if(single.status == SceneManual_pb.EMANUALSTATUS_UNLOCK or single.status == SceneManual_pb.EMANUALSTATUS_UNLOCK_CLIENT)then
|
||
table.insert(ret,single)
|
||
end
|
||
end
|
||
end
|
||
return ret
|
||
end
|
||
|
||
|
||
function AdventureDataProxy:getUnlockNumByType( type )
|
||
-- body
|
||
local ret = {}
|
||
local bgData = self.bagMap[type] or self.bagMap[SceneManual_pb.EMANUALTYPE_FASHION]-- or self.bagMap[SceneManual_pb.EMANUALTYPE_MOUNT]
|
||
|
||
local num = 0
|
||
if(bgData)then
|
||
local list = bgData:GetItems()
|
||
for i=1,#list do
|
||
local single = list[i]
|
||
if(single.status == SceneManual_pb.EMANUALSTATUS_UNLOCK)then
|
||
num = num+1
|
||
end
|
||
end
|
||
end
|
||
return tostring(num)
|
||
end
|
||
|
||
|
||
|
||
|
||
function AdventureDataProxy:getUnuploadScenerys( )
|
||
-- body
|
||
local ret = {}
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_SCENERY]
|
||
if(bgData)then
|
||
local list = bgData:GetItems()
|
||
for i=1,#list do
|
||
local single = list[i]
|
||
if(not single.attrUnlock)then
|
||
table.insert(ret,single)
|
||
end
|
||
end
|
||
end
|
||
return ret
|
||
end
|
||
|
||
function AdventureDataProxy:getUnLockMonsterByType( type ,status)
|
||
-- body
|
||
local ret = {}
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_MONSTER]
|
||
if(bgData)then
|
||
local list = bgData:GetItems()
|
||
for i=1,#list do
|
||
local single = list[i]
|
||
if(single.staticData and type == NpcData.NpcDetailedType[single.staticData.Type] and single.status > status)then
|
||
table.insert(ret,single)
|
||
end
|
||
end
|
||
end
|
||
return #ret
|
||
end
|
||
|
||
function AdventureDataProxy:getNextAchievement( )
|
||
-- body
|
||
local manualLevel = self:getManualLevel()
|
||
for i=1,#Table_AdventureLevel do
|
||
local single = Table_AdventureLevel[i]
|
||
if(single.id > manualLevel)then
|
||
return single
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:getNumOfStoredHeaddress( Quality )
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_FASHION]-- or self.bagMap[SceneManual_pb.EMANUALTYPE_MOUNT]
|
||
--bagMap字典，获取 `EMANUALTYPE_FASHION` 类型的背包数据，赋值给 `bgData`
|
||
local num = 0
|
||
--初始化一个计数器num 记录符合条件的物品数量
|
||
if(bgData)then
|
||
-- 检查 `bgData` 是否存在
|
||
local list = bgData:GetItems()
|
||
-- 获取背包中所有物品的列表，赋值list
|
||
for i=1,#list do -- for循环遍历list中的每一个物品
|
||
local single = list[i]
|
||
if(single.staticData and single.staticData.Quality == Quality and single.store)then
|
||
-- 检查当前物品的 `staticData` 是否存在，且物品的质量 `Quality` 是否等于传入参数的 `Quality`，并且该物品是否存储（`single.store` 为真）
|
||
num = num +1
|
||
end
|
||
end
|
||
end
|
||
return num
|
||
-- 返回符合条件的物品数量 `num`
|
||
end
|
||
|
||
|
||
|
||
function AdventureDataProxy:getNumOfStoredCard( Quality ) --卡片
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_CARD]
|
||
local num = 0
|
||
if(bgData)then
|
||
local list = bgData:GetItems()
|
||
for i=1,#list do
|
||
local single = list[i]
|
||
if(single.staticData and single.staticData.Quality == Quality and single.store)then
|
||
num = num +1
|
||
end
|
||
end
|
||
end
|
||
return num
|
||
end
|
||
|
||
function AdventureDataProxy:GetCurAdventureAppellation( )
|
||
-- body
|
||
local achData = MyselfProxy.Instance:GetCurManualAppellation( )
|
||
if(achData)then
|
||
return achData.id
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:getCurAchievement( )
|
||
-- body
|
||
local manualLevel = self:getManualLevel()
|
||
for i=1,#Table_AdventureLevel do
|
||
local single = Table_AdventureLevel[i]
|
||
if(single.id == manualLevel)then
|
||
return single
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:getAdventureSkillByAppellation( appellation )
|
||
-- body
|
||
local skills = {}
|
||
if(not self.adShopSkills)then
|
||
self.adShopSkills = {}
|
||
for k,v in pairs(Table_Skill) do
|
||
if(v.Contidion.riskid)then
|
||
table.insert(self.adShopSkills,v)
|
||
end
|
||
end
|
||
end
|
||
|
||
for i=1,#self.adShopSkills do
|
||
local single = self.adShopSkills[i]
|
||
if(single.Contidion.riskid == appellation)then
|
||
table.insert(skills,single.id)
|
||
end
|
||
end
|
||
return skills
|
||
end
|
||
|
||
function AdventureDataProxy:getAppendRewardByTargetId( targetId ,type)
|
||
-- body
|
||
TableUtility.ArrayClear(tempArrayData)
|
||
for k,v in pairs(Table_AdventureAppend) do
|
||
if(v.targetID == targetId and type == v.Content and v.Reward)then
|
||
table.insert(tempArrayData,v.Reward)
|
||
end
|
||
end
|
||
return tempArrayData
|
||
end
|
||
|
||
function AdventureDataProxy:checkHasMonsterDropCard( id )
|
||
-- body
|
||
if(id)then
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_CARD]
|
||
if(bgData)then
|
||
local list = bgData:GetItems()
|
||
for i=1,#list do
|
||
local single = list[i]
|
||
if(single.staticId == id and single.status ~= SceneManual_pb.EMANUALSTATUS_DISPLAY)then
|
||
return true
|
||
end
|
||
end
|
||
end
|
||
end
|
||
return false
|
||
end
|
||
|
||
function AdventureDataProxy:getItemsByCategoryAndClassify( classify,profession,id )
|
||
-- body
|
||
if(classify)then
|
||
TableUtility.ArrayClear(tempArrayData)
|
||
local types = {}
|
||
for i,v in pairs(Table_ItemTypeAdventureLog) do
|
||
local idFit = true
|
||
if(id ~= nil)then
|
||
idFit = id == v.id
|
||
end
|
||
if(v.Classify == classify and idFit)then
|
||
table.insert(types,v)
|
||
end
|
||
end
|
||
table.sort(types,function ( l,r )
|
||
-- body
|
||
return l.Order < r.Order
|
||
end)
|
||
for i=1,#types do
|
||
local single = types[i]
|
||
local bgData = self.bagMap[single.type]
|
||
if(bgData)then
|
||
local list = bgData:GetItems(single.id)
|
||
for i=1,#list do
|
||
local single = list[i]
|
||
if(profession and single.equipInfo)then
|
||
local profess = MyselfProxy.Instance:GetMyProfession()
|
||
if(single.equipInfo:CanUseByProfess(profess)) then
|
||
tempArrayData[#tempArrayData +1 ] = single
|
||
end
|
||
else
|
||
tempArrayData[#tempArrayData +1 ] = single
|
||
end
|
||
end
|
||
end
|
||
end
|
||
return tempArrayData
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:getLockNumInfoByClassify( classify )
|
||
-- body
|
||
local total = 0
|
||
local unlock = 0
|
||
if(classify)then
|
||
for i,v in pairs(Table_ItemTypeAdventureLog) do
|
||
if(v.Classify == classify)then
|
||
local bgData = self.bagMap[v.type]
|
||
if(bgData)then
|
||
local list = bgData:GetItems(v.id)
|
||
for i=1,#list do
|
||
local single = list[i]
|
||
if(single.type == SceneManual_pb.EMANUALTYPE_EQUIP )then
|
||
if(self:checkEquipIsUnlock(single.staticId))then
|
||
unlock = unlock +1
|
||
end
|
||
elseif(single.type == SceneManual_pb.EMANUALTYPE_HAIRSTYLE or single.type == SceneManual_pb.EMANUALTYPE_ITEM)then
|
||
if(self:checkShopItemIsUnlock(single.staticId))then
|
||
unlock = unlock +1
|
||
end
|
||
elseif(single.type == SceneManual_pb.EMANUALTYPE_MATE)then
|
||
if(self:checkMercenaryCatIsUnlock(single:getCatId()))then
|
||
unlock = unlock +1
|
||
end
|
||
end
|
||
total = total + 1
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
return unlock,total
|
||
end
|
||
|
||
function AdventureDataProxy:getMenuLockInfo( )
|
||
-- body
|
||
local total = 0
|
||
local unlock = 0
|
||
for i,v in pairs(Table_GameFunction) do
|
||
local menuId = v.MenuID
|
||
if(FunctionUnLockFunc.Me():CheckCanOpen(menuId))then
|
||
unlock = unlock + 1
|
||
end
|
||
total = total + 1
|
||
end
|
||
return unlock,total
|
||
end
|
||
|
||
function AdventureDataProxy:checkMercenaryCatIsUnlock(id)
|
||
-- body
|
||
local data = Table_MercenaryCat[id]
|
||
-- helplog("checkMercenaryCatIsUnlock1:",id)
|
||
if(data and data.MenuID)then
|
||
-- helplog("checkMercenaryCatIsUnlock1:",id)
|
||
-- helplog("checkMercenaryCatIsUnlock2:",FunctionUnLockFunc.Me():CheckCanOpen(data.MenuID))
|
||
if(not FunctionUnLockFunc.Me():CheckCanOpen(data.MenuID))then
|
||
return false
|
||
end
|
||
end
|
||
|
||
return true
|
||
end
|
||
|
||
function AdventureDataProxy:checkEquipIsUnlock(id)
|
||
-- body
|
||
for k,v in pairs(Table_Compose) do
|
||
if(v.Product and v.Product.id == id )then
|
||
if(not FunctionUnLockFunc.Me():CheckCanOpen(v.MenuID))then
|
||
return false
|
||
end
|
||
end
|
||
end
|
||
return true
|
||
end
|
||
|
||
function AdventureDataProxy:checkShopItemIsUnlock(id)
|
||
-- body
|
||
local staticData = Table_MenuUnclock[id]
|
||
if(staticData)then
|
||
local MenuID = staticData.MenuID
|
||
if(not FunctionUnLockFunc.Me():CheckCanOpen(MenuID))then
|
||
return false
|
||
end
|
||
end
|
||
return true
|
||
end
|
||
|
||
function AdventureDataProxy:GetMenuDesById(id)
|
||
local staticData = Table_MenuUnclock[id]
|
||
if(staticData)then
|
||
local MenuDes = staticData.MenuDes
|
||
return MenuDes
|
||
end
|
||
return nil;
|
||
end
|
||
|
||
function AdventureDataProxy.getUnlockCondition( data,notItem )
|
||
local str = ""
|
||
if(data.staticData and data.staticData.Condition)then
|
||
local condition = data.staticData.Condition
|
||
if(notItem)then
|
||
local pre = ""
|
||
if(data.staticData.Type ~= "MVP" and data.staticData.Type ~= "MINI" and data.type == SceneManual_pb.EMANUALTYPE_MONSTER)then
|
||
pre = ZhString.MonsterScoreTip_Condition
|
||
end
|
||
str = GameConfig.AdventureUnlockCodition[condition] or ""
|
||
str = pre..str..data:GetName()
|
||
else
|
||
for i=1,#GameConfig.AdventureUnlockCodition do
|
||
if(BitUtil.band(condition,i-1) ~= 0)then
|
||
-- if(i == #GameConfig.AdventureUnlockCodition)then
|
||
if(str == "")then
|
||
str = GameConfig.AdventureUnlockCodition[i]
|
||
else
|
||
str = str..ZhString.Common_Comma..GameConfig.AdventureUnlockCodition[i]
|
||
end
|
||
-- else
|
||
-- str = str..GameConfig.AdventureUnlockCodition[i].."、"
|
||
-- end
|
||
end
|
||
end
|
||
str = str..data:GetName()
|
||
end
|
||
return str
|
||
else
|
||
str = "please check Excel!!!"
|
||
end
|
||
return str
|
||
end
|
||
|
||
function AdventureDataProxy:getUnlockRewardStr( staticData, splitStr )
|
||
-- body
|
||
local advReward = staticData.AdventureReward
|
||
splitStr = splitStr or "\n"
|
||
if(type(advReward)=="table" and type(advReward.buffid)=="table")then
|
||
local str = ""
|
||
for i=1,#advReward.buffid do
|
||
-- local temp = {};
|
||
-- temp.type = "buffid";
|
||
local value = advReward.buffid[i];
|
||
local bufferData = Table_Buffer[value]
|
||
if bufferData and bufferData.Dsc ~= "" then
|
||
if(str ~= "")then
|
||
str = str..splitStr
|
||
end
|
||
str = str..(bufferData.Dsc or "");
|
||
end
|
||
end
|
||
return str
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:QueryUnresolvedPhotoManualCmd( data )
|
||
local photos = data.photos
|
||
self.tempAlbumTime = data.time
|
||
-- helplog("QueryUnresolvedPhotoManualCmd:")
|
||
self.tempScenerys = {}
|
||
if(photos and #photos>0)then
|
||
for i=1,#photos do
|
||
local single = photos[i]
|
||
local playerData = {}
|
||
local scenerys = nil
|
||
playerData.name = single.name
|
||
playerData.roleId = single.charid
|
||
-- helplog("QueryUnresolvedPhotoManualCmd:",single.name,single.charid)
|
||
for j=1,#single.photos do
|
||
local singleData = single.photos[j]
|
||
local tempData = {}
|
||
tempData.staticId = singleData.id
|
||
tempData.roleId = single.charid
|
||
tempData.time = singleData.time
|
||
scenerys = scenerys or {}
|
||
scenerys[#scenerys+1] = tempData
|
||
-- helplog("QueryUnresolvedPhotoManualCmd 11:",singleData.id,singleData.time)
|
||
MySceneryPictureManager.Instance():log("QueryUnresolvedPhotoManualCmd:",tostring(singleData.id),tostring(singleData.time),single.name,single.charid)
|
||
|
||
end
|
||
if(scenerys)then
|
||
playerData.scenerys = scenerys
|
||
self.tempScenerys[#self.tempScenerys+1] = playerData
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:UpdateResolvedPhotoManualCmd( data )
|
||
local roleId = data.charid
|
||
local sceneryId = data.sceneryid
|
||
if(self.tempScenerys)then
|
||
for i=1,#self.tempScenerys do
|
||
local single = self.tempScenerys[i]
|
||
if(single.roleId == roleId and single.scenerys and #single.scenerys>0)then
|
||
for j=1,#single.scenerys do
|
||
local singleScenery = single.scenerys[j]
|
||
if(singleScenery.staticId == sceneryId)then
|
||
table.remove(single.scenerys,j)
|
||
break
|
||
end
|
||
end
|
||
if(#single.scenerys == 0)then
|
||
table.remove(self.tempScenerys,i)
|
||
break
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:GetAllTempScenerys( )
|
||
return self.tempScenerys
|
||
end
|
||
|
||
function AdventureDataProxy:HasTempSceneryExsit( )
|
||
return #self.tempScenerys>0
|
||
end
|
||
|
||
function AdventureDataProxy:getIntoPackageRewardStr( staticData, splitStr )
|
||
-- body
|
||
local advReward = staticData.StorageReward
|
||
splitStr = splitStr or "\n"
|
||
if(type(advReward)=="table" and type(advReward.buffid)=="table")then
|
||
local str = ""
|
||
for i=1,#advReward.buffid do
|
||
local value = advReward.buffid[i];
|
||
local bufferData = Table_Buffer[value]
|
||
if bufferData and bufferData.Dsc ~= "" then
|
||
if(str ~= "")then
|
||
str = str..splitStr
|
||
end
|
||
str = str..(bufferData.Dsc or "");
|
||
end
|
||
end
|
||
return str
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:getNextAppellationProp( )
|
||
local achData = MyselfProxy.Instance:GetCurManualAppellation( )
|
||
local str = ""
|
||
if(achData)then
|
||
local staticData = Table_Appellation[achData.staticData.PostID]
|
||
if(staticData)then
|
||
str = string.format(ZhString.AdventureHomePage_TitleDes,staticData.Name)
|
||
for k,v in pairs(staticData.BaseProp) do
|
||
local prop = Game.Config_PropName[ k]
|
||
if(prop and v > 0)then
|
||
str = str.."\n"..prop.RuneName.."+"..v;
|
||
end
|
||
end
|
||
str = str.."[-][/c]"
|
||
end
|
||
end
|
||
return str
|
||
end
|
||
|
||
function AdventureDataProxy:getNextAdventureLevelProp( curLv )
|
||
-- body
|
||
curLv = curLv or self:getManualLevel()
|
||
local str = ""
|
||
local nextLv = curLv +1
|
||
local staticData = Table_AdventureLevel[nextLv]
|
||
if(staticData)then
|
||
if(staticData.AdventureAttr and next(staticData.AdventureAttr))then
|
||
local i = 0
|
||
for k,v in pairs(staticData.AdventureAttr) do
|
||
local prop = Game.Config_PropName[ k]
|
||
if(prop and v > 0)then
|
||
if(i == 0)then
|
||
str = prop.RuneName.."+"..v;
|
||
else
|
||
str = str.."\n"..prop.RuneName.."+"..v;
|
||
end
|
||
|
||
end
|
||
i = i+1
|
||
end
|
||
end
|
||
if(staticData.SkillPoint and staticData.SkillPoint>0)then
|
||
str = str..string.format(ZhString.AdventureHomePage_manualPoint,staticData.SkillPoint);
|
||
end
|
||
end
|
||
return str
|
||
end
|
||
|
||
function AdventureDataProxy:GetAppellationProp( )
|
||
TableUtility.ArrayClear(tempArrayData)
|
||
local id = self:GetCurAdventureAppellation()
|
||
local tempPropMap = {}
|
||
if(id)then
|
||
local count = id - 1000
|
||
for i=1,count do
|
||
local num = i+1000
|
||
local staticData = Table_Appellation[num]
|
||
if(staticData and next(staticData.BaseProp))then
|
||
for k,v in pairs(staticData.BaseProp) do
|
||
local prop = Game.Config_PropName[ k]
|
||
if(prop)then
|
||
local data = tempPropMap[k]
|
||
if(data)then
|
||
data.value = data.value + v
|
||
else
|
||
data = {}
|
||
data.value = v
|
||
data.prop = prop
|
||
tempArrayData[#tempArrayData+1] = data
|
||
end
|
||
tempPropMap[k] = data
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
return tempArrayData
|
||
end
|
||
|
||
function AdventureDataProxy:GetPropsByBufferId(buff,tempArrayData,tempMap)
|
||
if(buff and next(buff))then
|
||
for j=1,#buff do
|
||
local bufferData = Table_Buffer[buff[j]]
|
||
if(bufferData and bufferData.BuffEffect.type == "AttrChange" and bufferData.Condition == _EmptyTable)then
|
||
for k,v in pairs(bufferData.BuffEffect) do
|
||
local prop = Game.Config_PropName[ k]
|
||
if(prop)then
|
||
local data = tempMap[k]
|
||
if(data)then
|
||
data.value = data.value + v
|
||
else
|
||
data = {}
|
||
data.value = v
|
||
data.prop = prop
|
||
tempArrayData[#tempArrayData+1] = data
|
||
end
|
||
tempMap[k] = data
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:GetPropsByItemData(type,props,tempMap)
|
||
local bgData = self.bagMap[type]
|
||
if(bgData)then
|
||
local list = bgData:GetItems()
|
||
for i=1,#list do
|
||
local single = list[i]
|
||
if(single.staticData and next(single.staticData.AdventureReward) and single.status == SceneManual_pb.EMANUALSTATUS_UNLOCK)then
|
||
local buff = single.staticData.AdventureReward.buffid
|
||
self:GetPropsByBufferId(buff,props,tempMap)
|
||
end
|
||
|
||
if(single.staticData and next(single.staticData.StorageReward) and single.store)then
|
||
local buff = single.staticData.StorageReward.buffid
|
||
self:GetPropsByBufferId(buff,props,tempMap)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:GetPropsByPetData(props,tempMap)
|
||
local bgData = self.bagMap[SceneManual_pb.EMANUALTYPE_PET]
|
||
if(not bgData)then
|
||
return
|
||
end
|
||
|
||
local list = bgData:GetItems()
|
||
for i=1,#list do
|
||
local single = list[i]
|
||
local petData = single.staticData
|
||
if(petData and next(petData.AdventureReward) and single.status == SceneManual_pb.EMANUALSTATUS_UNLOCK)then
|
||
local buff = petData.AdventureReward.buffid
|
||
self:GetPropsByBufferId(buff,props,tempMap)
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:GetPropsByCollectGroupData(tempArrayData,tempMap)
|
||
for i=1,#self.collectionGroupDatas do
|
||
local single = self.collectionGroupDatas[i]
|
||
if(single:isTotalComplete() and single.staticData.RewardProperty)then
|
||
for k,v in pairs(single.staticData.RewardProperty) do
|
||
local prop = Game.Config_PropName[ k]
|
||
if(prop)then
|
||
local data = tempMap[k]
|
||
if(data)then
|
||
data.value = data.value + v
|
||
else
|
||
data = {}
|
||
data.value = v
|
||
data.prop = prop
|
||
tempArrayData[#tempArrayData+1] = data
|
||
end
|
||
tempMap[k] = data
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:GetPropsByTitleData(tempArrayData,tempMap)
|
||
local props = TitleProxy.Instance:GetAllTitleProp()
|
||
for k,v in pairs(props) do
|
||
local prop = Game.Config_PropName[ k]
|
||
if(prop)then
|
||
local data = tempMap[k]
|
||
if(data)then
|
||
data.value = data.value + v
|
||
else
|
||
data = {}
|
||
data.value = v
|
||
data.prop = prop
|
||
tempArrayData[#tempArrayData+1] = data
|
||
end
|
||
tempMap[k] = data
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:GetPropsByAppellationData(tempArrayData,tempMap)
|
||
local id = self:GetCurAdventureAppellation()
|
||
if(id)then
|
||
local count = id - 1000
|
||
for i=1,count do
|
||
local num = i+1000
|
||
local staticData = Table_Appellation[num]
|
||
if(staticData and next(staticData.BaseProp))then
|
||
for k,v in pairs(staticData.BaseProp) do
|
||
local prop = Game.Config_PropName[ k]
|
||
if(prop)then
|
||
local data = tempMap[k]
|
||
if(data)then
|
||
data.value = data.value + v
|
||
else
|
||
data = {}
|
||
data.value = v
|
||
data.prop = prop
|
||
tempArrayData[#tempArrayData+1] = data
|
||
end
|
||
tempMap[k] = data
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:GetPropsByBufferData(tempArrayData,tempMap)
|
||
-- if(MyselfProxy.Instance.buffAttr)then
|
||
-- for k,v in pairs(MyselfProxy.Instance.buffAttr) do
|
||
-- local prop = MyselfProxy.Instance.buffersProps[k]
|
||
-- if(prop and prop:GetValue() >0)then
|
||
-- local data = {}
|
||
-- data.prop = prop
|
||
-- data.type = BaseAttributeView.cellType.fixed
|
||
-- table.insert(datas,data)
|
||
-- end
|
||
-- end
|
||
-- end
|
||
end
|
||
|
||
function AdventureDataProxy:GetPropsByFoodData(tempArrayData,tempMap)
|
||
local food_cook_info = FoodProxy.Instance.food_cook_info
|
||
|
||
for k,cookInfo in pairs(food_cook_info) do
|
||
if(cookInfo.itemData and cookInfo.itemData.staticData and cookInfo.itemData.staticData.AdventureValue and cookInfo.itemData.staticData.AdventureValue ~=0 )then
|
||
local foodInfo = Table_Food[cookInfo.itemid]
|
||
if(cookInfo and cookInfo.level == 10 and next(foodInfo.CookLvAttr))then
|
||
for k,v in pairs(foodInfo.CookLvAttr) do
|
||
local prop = Game.Config_PropName[ k]
|
||
if(prop)then
|
||
local data = tempMap[k]
|
||
if(data)then
|
||
data.value = data.value + v
|
||
else
|
||
data = {}
|
||
data.value = v
|
||
data.prop = prop
|
||
tempArrayData[#tempArrayData+1] = data
|
||
end
|
||
tempMap[k] = data
|
||
end
|
||
end
|
||
end
|
||
|
||
--品嚐熟練度
|
||
local tasteInfo = FoodProxy.Instance:Get_FoodEatExpInfo(cookInfo.itemid)
|
||
if(tasteInfo and tasteInfo.level == 10 and next(foodInfo.TasteLvAttr))then
|
||
for k,v in pairs(foodInfo.TasteLvAttr) do
|
||
local prop = Game.Config_PropName[ k]
|
||
if(prop)then
|
||
local data = tempMap[k]
|
||
if(data)then
|
||
data.value = data.value + v
|
||
else
|
||
data = {}
|
||
data.value = v
|
||
data.prop = prop
|
||
tempArrayData[#tempArrayData+1] = data
|
||
end
|
||
tempMap[k] = data
|
||
end
|
||
end
|
||
end
|
||
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:GetAllAdventureProp( )
|
||
-- 此處顯示手冊內全部加成的永久屬性：
|
||
-- 1.頭飾解鎖&儲存獎勵的屬性
|
||
-- 2.卡片解鎖&儲存獎勵的屬性
|
||
-- 3.料理熟練度獎勵的屬性
|
||
-- 4.珍藏品獎勵的屬性
|
||
-- 5.以及以後會在手冊中增加的屬性
|
||
TableUtility.ArrayClear(tempArrayData)
|
||
|
||
local tempPropMap = {}
|
||
self:GetPropsByItemData(SceneManual_pb.EMANUALTYPE_CARD,tempArrayData,tempPropMap)
|
||
self:GetPropsByItemData(SceneManual_pb.EMANUALTYPE_FASHION,tempArrayData,tempPropMap)
|
||
self:GetPropsByItemData(SceneManual_pb.EMANUALTYPE_MOUNT,tempArrayData,tempPropMap)
|
||
self:GetPropsByItemData(SceneManual_pb.EMANUALTYPE_COLLECTION,tempArrayData,tempPropMap)
|
||
self:GetPropsByPetData(tempArrayData,tempPropMap)
|
||
self:GetPropsByFoodData(tempArrayData,tempPropMap)
|
||
self:GetPropsByTitleData(tempArrayData,tempPropMap)
|
||
self:GetPropsByCollectGroupData(tempArrayData,tempPropMap)
|
||
|
||
return tempArrayData
|
||
end
|
||
|
||
function AdventureDataProxy:CheckFashionCanMake( staticId )
|
||
local cid = Table_ItemBeTransformedWay[staticId] and Table_ItemBeTransformedWay[staticId].composeWay or 0
|
||
local composeData = Table_Compose[cid]
|
||
if(not composeData)then
|
||
return false
|
||
end
|
||
local costItem = composeData.BeCostItem
|
||
local tbItem = Table_Item
|
||
local bagtype = BagProxy.Instance:Get_PackageMaterialCheck_BagTypes(BagProxy.MaterialCheckBag_Type.adventureProduce)
|
||
for i=1,#costItem do
|
||
local single = costItem[i]
|
||
local itemData = tbItem[single.id]
|
||
if(itemData and itemData.Type ~= 50)then
|
||
local itemDatas = BagProxy.Instance:GetMaterialItems_ByItemId(single.id,bagtype)
|
||
local exsitNum = 0
|
||
if(itemDatas and #itemDatas>0)then
|
||
for j=1,#itemDatas do
|
||
local single = itemDatas[j]
|
||
exsitNum = exsitNum+single.num
|
||
end
|
||
end
|
||
|
||
local need = single.num or 0
|
||
if(need > exsitNum)then
|
||
return false
|
||
end
|
||
end
|
||
end
|
||
return true
|
||
end
|
||
|
||
function AdventureDataProxy:GetAllFixProp( )
|
||
TableUtility.ArrayClear(tempArrayData)
|
||
local tempPropMap = {}
|
||
self:GetPropsByFoodData(tempArrayData,tempPropMap)
|
||
self:GetPropsByCollectGroupData(tempArrayData,tempPropMap)
|
||
self:GetPropsByTitleData(tempArrayData,tempPropMap)
|
||
self:GetPropsByAppellationData(tempArrayData,tempPropMap)
|
||
self:GetPropsByBufferData(tempArrayData,tempPropMap)
|
||
-- self:GetPropsByPetData(tempArrayData,tempPropMap)
|
||
|
||
local props = RolePropsContainer.CreateAsTable()
|
||
if(props)then
|
||
for _, o in pairs(props.configs) do
|
||
props:SetValueById(o.id,0)
|
||
end
|
||
end
|
||
|
||
local datas = {}
|
||
for k,v in pairs(Game.Config_PropName) do
|
||
local prop = props[k]
|
||
local value = 0
|
||
local buffValue = MyselfProxy.Instance.buffersProps:GetValueByName(k)
|
||
local otherValue = 0
|
||
if(tempPropMap[k] and tempPropMap[k].value>0)then
|
||
otherValue = tempPropMap[k].value
|
||
end
|
||
value = otherValue + buffValue
|
||
if(value ~= 0 )then
|
||
local data = {}
|
||
if(prop.propVO.isPercent)then
|
||
value = value * 1000
|
||
end
|
||
prop:SetValue(value)
|
||
data.prop = prop
|
||
data.type = BaseAttributeView.cellType.fixed
|
||
table.insert(datas,data)
|
||
end
|
||
end
|
||
return datas
|
||
end
|
||
|
||
function AdventureDataProxy:checkFashionCanStore( itemData )
|
||
local card = itemData.type == SceneManual_pb.EMANUALTYPE_CARD
|
||
if(card)then
|
||
return BagProxy.Instance:GetItemByStaticID(itemData.staticId)
|
||
end
|
||
local tempArrayData = self:GetFashionEquipByStatic(itemData)
|
||
if(tempArrayData and #tempArrayData>0)then
|
||
return true
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:insertPropData( datas,roleDatas)
|
||
for i=1,#roleDatas do
|
||
local single = roleDatas[i]
|
||
datas[#datas+1] = single
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:getSinglePropDatas( propData,keys)
|
||
local datas = {}
|
||
if(not keys or #keys == 0)then
|
||
if(propData.subTable and next(propData.subTable))then
|
||
for k,v in pairs(propData.subTable) do
|
||
for k1,v1 in pairs(v) do
|
||
if(v1.roleDatas)then
|
||
self:insertPropData(datas,v1.roleDatas)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
else
|
||
for i=1,#keys do
|
||
local single = keys[i]
|
||
if(single.roleDatas)then
|
||
self:insertPropData(datas,single.roleDatas)
|
||
end
|
||
end
|
||
end
|
||
return datas
|
||
end
|
||
|
||
function AdventureDataProxy:getCollectionItemsByFilterData( items,propData,keys)
|
||
if(propData.propId == 7)then
|
||
TableUtility.ArrayClear(items)
|
||
return items
|
||
end
|
||
local retDatas = {}
|
||
|
||
local otherDatas = {}
|
||
|
||
local datas = self:getSinglePropDatas(propData,keys)
|
||
|
||
for i=1,#items do
|
||
local single = items[i]
|
||
local find = false
|
||
if(single.staticData.RewardProperty)then
|
||
for j=1,#datas do
|
||
local singleProp = datas[j]
|
||
if(single.staticData.RewardProperty[singleProp.VarName])then
|
||
retDatas[#retDatas+1] = single
|
||
find = true
|
||
break
|
||
end
|
||
end
|
||
end
|
||
if(not find)then
|
||
otherDatas[#otherDatas+1] = single
|
||
end
|
||
end
|
||
|
||
if(propData.propId == 8)then
|
||
return otherDatas
|
||
else
|
||
return retDatas
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:CheckBufferisSkillType( buffType)
|
||
for k,v in pairs(AdventureDataProxy.FilterSkillType) do
|
||
if(buffType == v)then
|
||
return true
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:CheckBufferisPropType( buffType)
|
||
for k,v in pairs(AdventureDataProxy.FilterPropType) do
|
||
if(buffType == v)then
|
||
return true
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:CheckBufferisOtherRequire( buff)
|
||
for k,v in pairs(GameConfig.AdventurePropClassify) do
|
||
local datas = self:getKeywords(k,v)
|
||
if(k ~= 8)then
|
||
datas = self:getSinglePropDatas(datas)
|
||
resutl = self:CheckBufferisRequire(buff,datas,k)
|
||
if(resutl)then
|
||
return true
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:CheckBufferisRequire( buff,datas,propid)
|
||
|
||
if(not buff or not next(buff) or not datas)then
|
||
return
|
||
end
|
||
for i=1,#buff do
|
||
local bufferData = Table_Buffer[buff[i]]
|
||
if(bufferData)then
|
||
if(propid == 7 and self:CheckBufferisSkillType(bufferData.BuffEffect.type))then
|
||
return true
|
||
elseif(self:CheckBufferisPropType(bufferData.BuffEffect.type))then
|
||
if(bufferData.BuffEffect.type == "AddBuff")then
|
||
return self:CheckBufferisRequire(bufferData.BuffEffect.id,datas,propid)
|
||
elseif(bufferData.BuffEffect.type == "ImmuneStatus" or bufferData.BuffEffect.type == "ResistStatus")then
|
||
local st = bufferData.BuffEffect.status[1]
|
||
local propKey = GameConfig.Status2RoleData and GameConfig.Status2RoleData[st]
|
||
prop = Game.Config_PropName[propKey]
|
||
if(prop)then
|
||
for j=1,#datas do
|
||
local singleProp = datas[j]
|
||
if(prop.id == singleProp.id)then
|
||
return true
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
|
||
for k,v in pairs(bufferData.BuffEffect) do
|
||
local prop = Game.Config_PropName[ k]
|
||
if(prop)then
|
||
for j=1,#datas do
|
||
local singleProp = datas[j]
|
||
if(prop.id == singleProp.id)then
|
||
return true
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:getNorItemsByFilterData( items,propData,keys)
|
||
local retDatas = {}
|
||
local datas = self:getSinglePropDatas(propData,keys)
|
||
local buffers = {}
|
||
for i=1,#items do
|
||
local single = items[i]
|
||
local beIn = false
|
||
TableUtility.ArrayClear(buffers)
|
||
if(single.staticData and next(single.staticData.AdventureReward))then
|
||
local buff = single.staticData.AdventureReward.buffid
|
||
beIn = self:CheckBufferisRequire(buff,datas,propData.propId)
|
||
buffers[#buffers+1] = buff
|
||
end
|
||
|
||
if(not beIn)then
|
||
if(single.staticData and next(single.staticData.StorageReward))then
|
||
local buff = single.staticData.StorageReward.buffid
|
||
beIn = self:CheckBufferisRequire(buff,datas,propData.propId)
|
||
buffers[#buffers+1] = buff
|
||
end
|
||
end
|
||
|
||
if(not beIn)then
|
||
if(single.cardInfo)then
|
||
local buff = single.cardInfo.BuffEffect.buff
|
||
beIn = self:CheckBufferisRequire(buff,datas,propData.propId)
|
||
buffers[#buffers+1] = buff
|
||
end
|
||
end
|
||
|
||
if(not beIn)then
|
||
if(single.equipInfo and single.equipInfo.equipData)then
|
||
local buff = single.equipInfo.equipData.UniqueEffect.buff
|
||
beIn = self:CheckBufferisRequire(buff,datas,propData.propId)
|
||
buffers[#buffers+1] = buff
|
||
end
|
||
end
|
||
if(beIn)then
|
||
retDatas[#retDatas+1] = single
|
||
end
|
||
if(not beIn and propData.propId == 8)then
|
||
local find = false
|
||
for j=1,#buffers do
|
||
local single = buffers[j]
|
||
find = self:CheckBufferisOtherRequire(single)
|
||
if(find)then
|
||
break
|
||
end
|
||
end
|
||
if(not find)then
|
||
retDatas[#retDatas+1] = single
|
||
end
|
||
end
|
||
end
|
||
return retDatas
|
||
end
|
||
|
||
function AdventureDataProxy:getItemsByFilterData( type,items,propData,keys)
|
||
if(not propData or #items==0)then
|
||
return items
|
||
end
|
||
if(type == SceneManual_pb.EMANUALTYPE_COLLECTION)then
|
||
items = self:getCollectionItemsByFilterData(items,propData,keys)
|
||
else
|
||
items = self:getNorItemsByFilterData(items,propData,keys)
|
||
end
|
||
return items
|
||
end
|
||
|
||
function AdventureDataProxy:getRoleDatas( filter,tag,id )
|
||
local roleDatas = {}
|
||
for k,v in pairs(Table_RoleData) do
|
||
local ret = v[tag] and (v[tag]& 2^(id-1))>0
|
||
if(next(filter))then
|
||
for k1,v1 in pairs(filter) do
|
||
for i=1,#v1 do
|
||
local ret2 = v[k1] and (v[k1]& 2^(v1[i].id-1))>0
|
||
if(ret and ret2)then
|
||
roleDatas[#roleDatas+1] = v
|
||
end
|
||
end
|
||
end
|
||
elseif(ret)then
|
||
roleDatas[#roleDatas+1] = v
|
||
end
|
||
end
|
||
return roleDatas
|
||
end
|
||
|
||
function AdventureDataProxy:getKeywords( propId,data )
|
||
|
||
local tRet = self.propTypeDatas[propId]
|
||
if(tRet)then
|
||
return tRet
|
||
end
|
||
|
||
local defaultGroup = data.defaultGroup
|
||
local group = data.group
|
||
|
||
local filterTable = {}
|
||
for k,v in pairs(defaultGroup) do
|
||
local fdata = filterTable[k] or {}
|
||
local ptdata = GameConfig.PropTag[k]
|
||
if(ptdata)then
|
||
for k1,v1 in pairs(ptdata) do
|
||
if(v&2^(k1-1) >0)then
|
||
fdata[#fdata+1] = {id = k1,name = v1,tag = k}
|
||
end
|
||
end
|
||
end
|
||
filterTable[k] = fdata
|
||
end
|
||
|
||
local subTable = {}
|
||
|
||
for k,v in pairs(group) do
|
||
local fdata = subTable[k] or {}
|
||
local ptdata = GameConfig.PropTag[k]
|
||
if(ptdata)then
|
||
for k1,v1 in pairs(ptdata) do
|
||
if(v&2^(k1-1) >0)then
|
||
local roleDatas = self:getRoleDatas(filterTable,k,k1)
|
||
fdata[#fdata+1] = {id = k1,name = v1,tag = k,roleDatas = roleDatas}
|
||
end
|
||
end
|
||
end
|
||
subTable[k] = fdata
|
||
end
|
||
|
||
tRet = {subTable = subTable,filterTable = filterTable,propId = propId}
|
||
self.propTypeDatas[propId] = tRet
|
||
return tRet
|
||
end
|
||
|
||
function AdventureDataProxy:GetFashionEquipByStatic( itemData )
|
||
local equipInfo = itemData.equipInfo
|
||
if(equipInfo and equipInfo.equipData)then
|
||
local GroupID = equipInfo.equipData.GroupID
|
||
TableUtility.ArrayClear(tempArrayData)
|
||
if(GroupID)then
|
||
local equipDatas = self.fashionGroupData[GroupID]
|
||
if(equipDatas)then
|
||
for i=1,#equipDatas do
|
||
local single = equipDatas[i]
|
||
local data = BagProxy.Instance:GetItemByStaticIDWithoutCard(single.id)
|
||
if(data)then
|
||
tempArrayData[#tempArrayData+1] = data
|
||
end
|
||
end
|
||
end
|
||
else
|
||
tempArrayData[#tempArrayData+1] = BagProxy.Instance:GetItemByStaticIDWithoutCard(itemData.staticId)
|
||
end
|
||
return tempArrayData
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:GetFashionEquipByStaticNormal( itemData )
|
||
local equipInfo = itemData.equipInfo
|
||
if(equipInfo and equipInfo.equipData)then
|
||
local GroupID = equipInfo.equipData.GroupID
|
||
TableUtility.ArrayClear(tempArrayData)
|
||
if(GroupID)then
|
||
local equipDatas = self.fashionGroupData[GroupID]
|
||
if(equipDatas)then
|
||
for i=1,#equipDatas do
|
||
local single = equipDatas[i]
|
||
local data = BagProxy.Instance:GetItemByStaticID(single.id)
|
||
if(data)then
|
||
tempArrayData[#tempArrayData+1] = data
|
||
end
|
||
end
|
||
end
|
||
else
|
||
tempArrayData[#tempArrayData+1] = BagProxy.Instance:GetItemByStaticID(itemData.staticId)
|
||
end
|
||
return tempArrayData
|
||
end
|
||
end
|
||
|
||
function AdventureDataProxy:FilterEquipByProp( )
|
||
-- body
|
||
-- local GetFashionEquipByStatic
|
||
end
|
||
|
||
function AdventureDataProxy:Test( )
|
||
-- body
|
||
local list = {}
|
||
for i=1,3 do
|
||
local data = {}
|
||
data.name = "xx："..i
|
||
data.charid = i*10000+i*10
|
||
local scenerys = {}
|
||
for j=1,10 do
|
||
local tempData = {}
|
||
tempData.id = j
|
||
tempData.time = 10000
|
||
scenerys[#scenerys+1] = tempData
|
||
end
|
||
data.photos = scenerys
|
||
list[#list+1] = data
|
||
end
|
||
local data = {}
|
||
data.photos = list
|
||
self:QueryUnresolvedPhotoManualCmd(data)
|
||
end |