SL1900
1856 lines
65 KiB
Lua
1856 lines
65 KiB
Lua
local StarTowerSweepData = class("StarTowerSweepData")
|
||
local WwiseAudioMgr = CS.WwiseAudioManager.Instance
|
||
local mapEventConfig = {}
|
||
function StarTowerSweepData:ctor(nStarTowerId)
|
||
self.EnumCase = {
|
||
Battle = 1,
|
||
OpenDoor = 2,
|
||
PotentialSelect = 3,
|
||
FateCardSelect = 4,
|
||
NoteSelect = 5,
|
||
NpcEvent = 6,
|
||
SelectSpecialPotential = 7,
|
||
RecoveryHP = 8,
|
||
NpcRecoveryHP = 9,
|
||
Hawker = 10,
|
||
StrengthenMachine = 11,
|
||
DoorDanger = 12,
|
||
SyncHP = 13
|
||
}
|
||
self.EnumPopup = {
|
||
Disc = 1,
|
||
Reward = 2,
|
||
Potential = 3,
|
||
StrengthFx = 4,
|
||
Affinity = 5
|
||
}
|
||
self:BindEvent()
|
||
local BuildStarTowerAllFloorData = function(nTowerId)
|
||
local mapStarTowerCfgData = ConfigTable.GetData("StarTower", nTowerId)
|
||
if mapStarTowerCfgData == nil then
|
||
return {}
|
||
end
|
||
local ret = {}
|
||
local levelDifficulty = mapStarTowerCfgData.Difficulty
|
||
local difficulty = mapStarTowerCfgData.ValueDifficulty
|
||
local tbStage = mapStarTowerCfgData.StageGroupIds
|
||
local tbFloorNum = mapStarTowerCfgData.FloorNum
|
||
for nIdx, nStageGroupId in ipairs(tbStage) do
|
||
local nFloorNum = tbFloorNum[nIdx]
|
||
if nFloorNum == nil then
|
||
nFloorNum = 99
|
||
printError("FloorNum Missing��" .. nTowerId .. " " .. nIdx)
|
||
end
|
||
for nLevel = 1, nFloorNum do
|
||
local nStageLevelId = nStageGroupId * 100 + nLevel
|
||
if ConfigTable.GetData("StarTowerStage", nStageLevelId) == nil then
|
||
break
|
||
end
|
||
table.insert(ret, ConfigTable.GetData("StarTowerStage", nStageLevelId))
|
||
end
|
||
end
|
||
return ret, difficulty, levelDifficulty
|
||
end
|
||
local BuildStarTowerExpData = function(nTowerId)
|
||
local ret = {}
|
||
local forEachExp = function(mapData)
|
||
if mapData.StarTowerId == nTowerId then
|
||
ret[mapData.Stage] = mapData
|
||
end
|
||
end
|
||
ForEachTableLine(DataTable.StarTowerFloorExp, forEachExp)
|
||
return ret
|
||
end
|
||
self.nTowerId = nStarTowerId
|
||
self.nCurLevel = 1
|
||
self.bRanking = false
|
||
self.tbStarTowerAllLevel, self.nStarTowerDifficulty, self.nStarTowerLevelDifficulty = BuildStarTowerAllFloorData(self.nTowerId)
|
||
self.mapFloorExp = BuildStarTowerExpData(self.nTowerId)
|
||
self.tbStrengthMachineCost = ConfigTable.GetConfigNumberArray("StrengthenMachineGoldConsume")
|
||
end
|
||
function StarTowerSweepData:BindEvent()
|
||
if type(mapEventConfig) ~= "table" then
|
||
return
|
||
end
|
||
for nEventId, sCallbackName in pairs(mapEventConfig) do
|
||
local callback = self[sCallbackName]
|
||
if type(callback) == "function" then
|
||
EventManager.Add(nEventId, self, callback)
|
||
end
|
||
end
|
||
end
|
||
function StarTowerSweepData:UnBindEvent()
|
||
if type(mapEventConfig) ~= "table" then
|
||
return
|
||
end
|
||
for nEventId, sCallbackName in pairs(mapEventConfig) do
|
||
local callback = self[sCallbackName]
|
||
if type(callback) == "function" then
|
||
EventManager.Remove(nEventId, self, callback)
|
||
end
|
||
end
|
||
end
|
||
function StarTowerSweepData:Init(mapMeta, mapRoom, mapBag)
|
||
local GetCharacterAttr = function(tbTeam, mapDisc)
|
||
local ret = {}
|
||
for idx, nTid in ipairs(tbTeam) do
|
||
local stActorInfo = self:CalCharFixedEffect(nTid, idx == 1, mapDisc)
|
||
ret[nTid] = stActorInfo
|
||
end
|
||
return ret
|
||
end
|
||
self.mapCharData, self.mapDiscData = self:BuildCharacterData(mapMeta.Chars, mapMeta.Discs)
|
||
self._mapNote = {}
|
||
local mapCfg = ConfigTable.GetData("StarTower", mapMeta.Id)
|
||
if mapCfg ~= nil then
|
||
local nDropGroup = mapCfg.SubNoteSkillDropGroupId
|
||
local tbNoteDrop = CacheTable.GetData("_SubNoteSkillDropGroup", nDropGroup)
|
||
if tbNoteDrop ~= nil then
|
||
for _, v in ipairs(tbNoteDrop) do
|
||
self._mapNote[v.SubNoteSkillId] = 0
|
||
end
|
||
end
|
||
end
|
||
self._mapPotential = {}
|
||
self._mapFateCard = {}
|
||
self._mapItem = {}
|
||
self.tbTeam = {}
|
||
self.mapPotentialAddLevel = {}
|
||
for _, mapChar in ipairs(mapMeta.Chars) do
|
||
table.insert(self.tbTeam, mapChar.Id)
|
||
self._mapPotential[mapChar.Id] = {}
|
||
local tbActive = self.mapCharData[mapChar.Id].tbActive
|
||
local tbEquipment = self.mapCharData[mapChar.Id].tbEquipment
|
||
self.mapPotentialAddLevel[mapChar.Id] = self:GetCharEnhancedPotential(tbActive, tbEquipment)
|
||
end
|
||
self.tbDisc = {}
|
||
for _, mapDisc in ipairs(mapMeta.Discs) do
|
||
table.insert(self.tbDisc, mapDisc.Id)
|
||
end
|
||
self.nTowerId = mapMeta.Id
|
||
self.nCurLevel = mapRoom.Data.Floor
|
||
self.tbActiveSecondaryIds = mapMeta.ActiveSecondaryIds
|
||
self.tbGrowthNodeEffect = PlayerData.StarTower:GetClientEffectByNode(mapMeta.TowerGrowthNodes)
|
||
self.nResurrectionCnt = mapMeta.ResurrectionCnt or 0
|
||
self.nTeamLevel = mapMeta.TeamLevel
|
||
self.nTeamExp = mapMeta.TeamExp
|
||
self.nTotalTime = mapMeta.TotalTime
|
||
if self.nRankBattleTime == nil then
|
||
self.nRankBattleTime = 0
|
||
end
|
||
self.nRoomType = mapRoom.Data.RoomType == nil and -1 or mapRoom.Data.RoomType
|
||
local mapStarTower = ConfigTable.GetData("StarTower", self.nTowerId)
|
||
if mapStarTower then
|
||
local nTeamIndex = PlayerData.StarTower:GetGroupFormation(mapStarTower.GroupId)
|
||
local nPreselectionId = PlayerData.Team:GetTeamPreselectionId(nTeamIndex)
|
||
self.mapPreselectionData = PlayerData.PotentialPreselection:GetPreselectionById(nPreselectionId)
|
||
end
|
||
if mapBag ~= nil then
|
||
for _, mapFateCardEft in ipairs(mapBag.FateCard) do
|
||
self._mapFateCard[mapFateCardEft.Tid] = {
|
||
mapFateCardEft.Remain,
|
||
mapFateCardEft.Room
|
||
}
|
||
end
|
||
for _, mapPotential in ipairs(mapBag.Potentials) do
|
||
local nTid = mapPotential.Tid
|
||
local mapPotentialCfgData = ConfigTable.GetData("Potential", nTid)
|
||
if mapPotentialCfgData == nil then
|
||
printError("PotentialCfgData Missing" .. nTid)
|
||
else
|
||
local nCharId = mapPotentialCfgData.CharId
|
||
if self._mapPotential[nCharId] == nil then
|
||
self._mapPotential[nCharId] = {}
|
||
end
|
||
self._mapPotential[nCharId][nTid] = mapPotential.Level
|
||
end
|
||
end
|
||
for _, mapItem in ipairs(mapBag.Items) do
|
||
local mapItemCfgData = ConfigTable.GetData_Item(mapItem.Tid)
|
||
if mapItemCfgData ~= nil and mapItemCfgData.Stype == GameEnum.itemStype.SubNoteSkill then
|
||
self._mapNote[mapItem.Tid] = mapItem.Qty
|
||
else
|
||
self._mapItem[mapItem.Tid] = mapItem.Qty
|
||
end
|
||
end
|
||
for _, mapItem in ipairs(mapBag.Res) do
|
||
self._mapItem[mapItem.Tid] = mapItem.Qty
|
||
end
|
||
end
|
||
self:InitRoom(mapRoom.Cases)
|
||
end
|
||
function StarTowerSweepData:BuildCharacterData(tbCharacterData, tbDiscData)
|
||
local EquipmentData = require("GameCore.Data.DataClass.EquipmentDataEx")
|
||
local DiscData = require("GameCore.Data.DataClass.DiscData")
|
||
local mapCharacter = {}
|
||
local mapDisc = {}
|
||
for idx, mapChar in ipairs(tbCharacterData) do
|
||
local tbEquipment, tbEquipmentSlot = {}, {}
|
||
for _, starTowerEquipment in ipairs(mapChar.Gems) do
|
||
if starTowerEquipment.Attributes then
|
||
local bEmpty = false
|
||
for _, v in pairs(starTowerEquipment.Attributes) do
|
||
if v == 0 then
|
||
bEmpty = true
|
||
break
|
||
end
|
||
end
|
||
if not bEmpty then
|
||
local nGemId = PlayerData.Equipment:GetGemIdBySlot(mapChar.Id, starTowerEquipment.SlotId)
|
||
local mapEquipmentInfo = {
|
||
Lock = false,
|
||
Attributes = starTowerEquipment.Attributes,
|
||
AlterAttributes = {},
|
||
OverlockCount = starTowerEquipment.OverlockCount,
|
||
AlterOverlockCount = {}
|
||
}
|
||
local equipmentData = EquipmentData.new(mapEquipmentInfo, mapChar.Id, nGemId)
|
||
table.insert(tbEquipment, equipmentData)
|
||
tbEquipmentSlot[starTowerEquipment.SlotId] = equipmentData
|
||
end
|
||
end
|
||
end
|
||
local tbTalent = CacheTable.GetData("_TalentByIndex", mapChar.Id)
|
||
if tbTalent == nil then
|
||
printError("Talent���Ҳ����ý�ɫ" .. mapChar.Id)
|
||
tbTalent = {}
|
||
end
|
||
local tbActive = {}
|
||
local tbNodes = UTILS.ParseByteString(mapChar.TalentNodes)
|
||
for nIndex, v in pairs(tbTalent) do
|
||
local bActive = UTILS.IsBitSet(tbNodes, nIndex)
|
||
if bActive then
|
||
table.insert(tbActive, v.Id)
|
||
end
|
||
end
|
||
local GetCharSkillAddedLevel = function(nCharId, tbSkillLv, active, bMainChar)
|
||
local tbSkillLevel = {}
|
||
local tbSkillIds = {}
|
||
local charCfgData = DataTable.Character[nCharId]
|
||
tbSkillIds[1] = charCfgData.NormalAtkId
|
||
tbSkillIds[2] = charCfgData.SkillId
|
||
tbSkillIds[3] = charCfgData.AssistSkillId
|
||
tbSkillIds[4] = charCfgData.UltimateId
|
||
local mapTalentEnhanceSkill = PlayerData.Talent:CreateEnhancedSkill(nCharId, active)
|
||
local mapEquipmentEnhanceSkill = {}
|
||
for _, v in pairs(tbEquipment) do
|
||
local tbSkill = v:GetEnhancedSkill()
|
||
for nSkillId, nAdd in pairs(tbSkill) do
|
||
if not mapEquipmentEnhanceSkill[nSkillId] then
|
||
mapEquipmentEnhanceSkill[nSkillId] = 0
|
||
end
|
||
mapEquipmentEnhanceSkill[nSkillId] = mapEquipmentEnhanceSkill[nSkillId] + nAdd
|
||
end
|
||
end
|
||
for i = 1, 4 do
|
||
local nSkillId = tbSkillIds[i]
|
||
local nAdd = 0
|
||
if mapTalentEnhanceSkill and mapTalentEnhanceSkill[nSkillId] then
|
||
nAdd = nAdd + mapTalentEnhanceSkill[nSkillId]
|
||
end
|
||
if mapEquipmentEnhanceSkill and mapEquipmentEnhanceSkill[nSkillId] then
|
||
nAdd = nAdd + mapEquipmentEnhanceSkill[nSkillId]
|
||
end
|
||
local nLv = tbSkillLv[i] + nAdd
|
||
table.insert(tbSkillLevel, nLv)
|
||
end
|
||
if bMainChar == true then
|
||
table.remove(tbSkillLevel, 3)
|
||
else
|
||
table.remove(tbSkillLevel, 2)
|
||
end
|
||
return tbSkillLevel
|
||
end
|
||
local tbTalentEffect = {}
|
||
for _, nTalentId in pairs(tbActive) do
|
||
local mapCfg = ConfigTable.GetData("Talent", nTalentId)
|
||
if mapCfg ~= nil then
|
||
for _, nEffectId in pairs(mapCfg.EffectId) do
|
||
table.insert(tbTalentEffect, nEffectId)
|
||
end
|
||
end
|
||
end
|
||
local tbAffinityeffectIds = {}
|
||
local mapCfg = ConfigTable.GetData("CharAffinityTemplate", mapChar.Id)
|
||
if mapCfg ~= nil then
|
||
local templateId = mapCfg.TemplateId
|
||
local forEachAffinityLevel = function(affinityData)
|
||
if affinityData.TemplateId == templateId and mapChar.AffinityLevel ~= nil and affinityData.AffinityLevel <= mapChar.AffinityLevel and affinityData.Effect ~= nil and #affinityData.Effect > 0 then
|
||
for k, v in ipairs(affinityData.Effect) do
|
||
table.insert(tbAffinityeffectIds, v)
|
||
end
|
||
end
|
||
end
|
||
ForEachTableLine(DataTable.AffinityLevel, forEachAffinityLevel)
|
||
end
|
||
local charData = {
|
||
nId = mapChar.Id,
|
||
nRankExp = 0,
|
||
nFavor = 0,
|
||
nSkinId = PlayerData.Char:GetCharUsedSkinId(mapChar.Id),
|
||
tbEquipment = tbEquipment,
|
||
tbEquipmentSlot = tbEquipmentSlot,
|
||
nLevel = mapChar.Level,
|
||
nCreateTime = 0,
|
||
nAdvance = mapChar.Advance,
|
||
tbSkillLvs = GetCharSkillAddedLevel(mapChar.Id, mapChar.SkillLvs, tbActive, idx == 1),
|
||
bUseSkillWhenActive_Branch1 = false,
|
||
bUseSkillWhenActive_Branch2 = false,
|
||
tbPlot = {},
|
||
nAffinityExp = 0,
|
||
nAffinityLevel = mapChar.AffinityLevel,
|
||
tbAffinityQuests = {},
|
||
tbActive = tbActive,
|
||
tbAffinityeffectIds = tbAffinityeffectIds,
|
||
tbTalentEffect = tbTalentEffect
|
||
}
|
||
mapCharacter[mapChar.Id] = charData
|
||
end
|
||
for _, startowerDisc in ipairs(tbDiscData) do
|
||
local mapDiscInfo = {
|
||
Id = startowerDisc.Id,
|
||
Level = startowerDisc.Level,
|
||
Exp = 0,
|
||
Phase = startowerDisc.Phase,
|
||
Star = startowerDisc.Star,
|
||
Read = false,
|
||
CreatTime = 0
|
||
}
|
||
local discData = DiscData.new(mapDiscInfo)
|
||
mapDisc[startowerDisc.Id] = discData
|
||
end
|
||
return mapCharacter, mapDisc
|
||
end
|
||
function StarTowerSweepData:GetCharEnhancedPotential(tbActiveTalent, tbEquipment)
|
||
local mapAddLevel = {}
|
||
local add = function(mapAdd)
|
||
if not mapAdd then
|
||
return
|
||
end
|
||
for nPotentialId, nAdd in pairs(mapAdd) do
|
||
if not mapAddLevel[nPotentialId] then
|
||
mapAddLevel[nPotentialId] = 0
|
||
end
|
||
mapAddLevel[nPotentialId] = mapAddLevel[nPotentialId] + nAdd
|
||
end
|
||
end
|
||
local mapTalentAddLevel = PlayerData.Talent:CreateEnhancedPotential(tbActiveTalent)
|
||
local mapEquipmentAddLevel = {}
|
||
for _, v in pairs(tbEquipment) do
|
||
local tbPotential = v:GetEnhancedPotential()
|
||
for nPotentialId, nAdd in pairs(tbPotential) do
|
||
if not mapEquipmentAddLevel[nPotentialId] then
|
||
mapEquipmentAddLevel[nPotentialId] = 0
|
||
end
|
||
mapEquipmentAddLevel[nPotentialId] = mapEquipmentAddLevel[nPotentialId] + nAdd
|
||
end
|
||
end
|
||
add(mapTalentAddLevel)
|
||
add(mapEquipmentAddLevel)
|
||
return mapAddLevel
|
||
end
|
||
function StarTowerSweepData:InitRoom(tbCases)
|
||
self.bEnd = false
|
||
self.tbEvent = {}
|
||
self.roomData = {}
|
||
self.mapCases = {}
|
||
self.bProcessing = true
|
||
self.nTaskType = 0
|
||
self.mapNpc = {}
|
||
self:SaveCase(tbCases)
|
||
self.tbPopup = {}
|
||
self.blockNpcBtn = false
|
||
end
|
||
function StarTowerSweepData:SaveCase(tbCases)
|
||
for _, mapCaseData in ipairs(tbCases) do
|
||
if mapCaseData.BattleCase ~= nil then
|
||
print("BattleCase")
|
||
if self.mapCases[self.EnumCase.Battle] ~= nil then
|
||
printError("ս���¼��ظ� ���ܵ��·����¼�����������")
|
||
end
|
||
self.mapCases[self.EnumCase.Battle] = {}
|
||
self.mapCases[self.EnumCase.Battle].Id = mapCaseData.Id
|
||
self.mapCases[self.EnumCase.Battle].Data = mapCaseData.BattleCase
|
||
self.mapCases[self.EnumCase.Battle].bFinish = false
|
||
elseif mapCaseData.DoorCase ~= nil then
|
||
if mapCaseData.DoorCase.Type == GameEnum.starTowerRoomType.DangerRoom then
|
||
print("DangerRoomCase")
|
||
local mapStarTower = ConfigTable.GetData("StarTower", self.nTowerId)
|
||
local nNpcId = mapStarTower.DangerNpc
|
||
local mapNpcCfgData = ConfigTable.GetData("NPCConfig", nNpcId)
|
||
local nBoardNpcId = mapNpcCfgData.NPCId
|
||
self.mapNpc[nNpcId] = mapCaseData.Id
|
||
if self.mapCases[self.EnumCase.DoorDanger] == nil then
|
||
self.mapCases[self.EnumCase.DoorDanger] = {}
|
||
end
|
||
self.mapCases[self.EnumCase.DoorDanger][mapCaseData.Id] = mapCaseData.DoorCase
|
||
self.mapCases[self.EnumCase.DoorDanger][mapCaseData.Id].bFinish = false
|
||
self.mapCases[self.EnumCase.DoorDanger][mapCaseData.Id].NpcId = nNpcId
|
||
elseif mapCaseData.DoorCase.Type == GameEnum.starTowerRoomType.HorrorRoom then
|
||
print("HorrorRoomCase")
|
||
local mapStarTower = ConfigTable.GetData("StarTower", self.nTowerId)
|
||
local nNpcId = mapStarTower.HorrorNpc
|
||
self.mapNpc[nNpcId] = mapCaseData.Id
|
||
if self.mapCases[self.EnumCase.DoorDanger] == nil then
|
||
self.mapCases[self.EnumCase.DoorDanger] = {}
|
||
end
|
||
self.mapCases[self.EnumCase.DoorDanger][mapCaseData.Id] = mapCaseData.DoorCase
|
||
self.mapCases[self.EnumCase.DoorDanger][mapCaseData.Id].bFinish = false
|
||
self.mapCases[self.EnumCase.DoorDanger][mapCaseData.Id].NpcId = nNpcId
|
||
else
|
||
print("DoorCase")
|
||
if self.mapCases[self.EnumCase.OpenDoor] == nil then
|
||
self.mapCases[self.EnumCase.OpenDoor] = {
|
||
mapCaseData.Id,
|
||
mapCaseData.DoorCase.Type
|
||
}
|
||
end
|
||
end
|
||
elseif mapCaseData.SelectPotentialCase ~= nil then
|
||
print("SelectPotentialCase")
|
||
if self.mapCases[self.EnumCase.PotentialSelect] == nil then
|
||
self.mapCases[self.EnumCase.PotentialSelect] = {}
|
||
end
|
||
self.mapCases[self.EnumCase.PotentialSelect][mapCaseData.Id] = mapCaseData.SelectPotentialCase
|
||
self.mapCases[self.EnumCase.PotentialSelect][mapCaseData.Id].bFinish = false
|
||
elseif mapCaseData.SelectSpecialPotentialCase ~= nil then
|
||
print("SelectSpecialPotentialCase")
|
||
if self.mapCases[self.EnumCase.SelectSpecialPotential] == nil then
|
||
self.mapCases[self.EnumCase.SelectSpecialPotential] = {}
|
||
end
|
||
self.mapCases[self.EnumCase.SelectSpecialPotential][mapCaseData.Id] = mapCaseData.SelectSpecialPotentialCase
|
||
self.mapCases[self.EnumCase.SelectSpecialPotential][mapCaseData.Id].bFinish = false
|
||
elseif mapCaseData.SelectFateCardCase ~= nil then
|
||
print("SelectFateCardCase")
|
||
if self.mapCases[self.EnumCase.FateCardSelect] == nil then
|
||
self.mapCases[self.EnumCase.FateCardSelect] = {}
|
||
end
|
||
self.mapCases[self.EnumCase.FateCardSelect][mapCaseData.Id] = mapCaseData.SelectFateCardCase
|
||
self.mapCases[self.EnumCase.FateCardSelect][mapCaseData.Id].bFinish = false
|
||
elseif mapCaseData.SelectNoteCase ~= nil then
|
||
print("SelectNoteCase")
|
||
if self.mapCases[self.EnumCase.NoteSelect] == nil then
|
||
self.mapCases[self.EnumCase.NoteSelect] = {}
|
||
end
|
||
self.mapCases[self.EnumCase.NoteSelect][mapCaseData.Id] = mapCaseData.SelectNoteCase
|
||
self.mapCases[self.EnumCase.NoteSelect][mapCaseData.Id].bFinish = false
|
||
elseif mapCaseData.SelectOptionsEventCase ~= nil then
|
||
print("SelectOptionsEventCase")
|
||
if self.mapCases[self.EnumCase.NpcEvent] == nil then
|
||
self.mapCases[self.EnumCase.NpcEvent] = {}
|
||
end
|
||
local mapEventCfgData = ConfigTable.GetData("StarTowerEvent", mapCaseData.SelectOptionsEventCase.EvtId)
|
||
if mapEventCfgData ~= nil then
|
||
local nNpcId = mapCaseData.SelectOptionsEventCase.NPCId
|
||
local mapNpcCfgData = ConfigTable.GetData("NPCConfig", nNpcId)
|
||
if mapNpcCfgData ~= nil then
|
||
local nBoardNpcId = mapNpcCfgData.NPCId
|
||
local nSkinId = PlayerData.Board:GetNPCUsingSkinId(nBoardNpcId)
|
||
if self.mapNpc[nNpcId] ~= nil then
|
||
printError("NpcId�ظ�" .. mapCaseData.SelectOptionsEventCase.EvtId)
|
||
end
|
||
self.mapNpc[nNpcId] = mapCaseData.Id
|
||
local nActionId = mapCaseData.SelectOptionsEventCase.EvtId * 10000 + nNpcId
|
||
if ConfigTable.GetData("StarTowerEventAction", nActionId) ~= nil then
|
||
mapCaseData.SelectOptionsEventCase.nActionId = nActionId
|
||
else
|
||
printError("���¼�û�ж�Ӧ��action" .. mapCaseData.SelectOptionsEventCase.EvtId)
|
||
mapCaseData.SelectOptionsEventCase.nActionId = 0
|
||
end
|
||
else
|
||
printError("û���ҵ���ӦNPC���� " .. nNpcId)
|
||
end
|
||
end
|
||
self.mapCases[self.EnumCase.NpcEvent][mapCaseData.Id] = mapCaseData.SelectOptionsEventCase
|
||
self.mapCases[self.EnumCase.NpcEvent][mapCaseData.Id].bFinish = mapCaseData.SelectOptionsEventCase.Done
|
||
self.mapCases[self.EnumCase.NpcEvent][mapCaseData.Id].bFirst = true
|
||
elseif mapCaseData.RecoveryHPCase ~= nil then
|
||
print("RecoveryHPCase")
|
||
if self.mapCases[self.EnumCase.RecoveryHP] == nil then
|
||
self.mapCases[self.EnumCase.RecoveryHP] = {}
|
||
end
|
||
self.mapCases[self.EnumCase.RecoveryHP][mapCaseData.Id] = mapCaseData.RecoveryHPCase
|
||
self.mapCases[self.EnumCase.RecoveryHP][mapCaseData.Id].bFinish = false
|
||
elseif mapCaseData.NpcRecoveryHPCase ~= nil then
|
||
print("NpcRecoveryHPCase")
|
||
local mapStarTower = ConfigTable.GetData("StarTower", self.nTowerId)
|
||
local nNpcId = mapStarTower.ResqueNpc
|
||
self.mapNpc[nNpcId] = mapCaseData.Id
|
||
if self.mapCases[self.EnumCase.NpcRecoveryHP] == nil then
|
||
self.mapCases[self.EnumCase.NpcRecoveryHP] = {}
|
||
end
|
||
self.mapCases[self.EnumCase.NpcRecoveryHP][mapCaseData.Id] = mapCaseData.NpcRecoveryHPCase
|
||
self.mapCases[self.EnumCase.NpcRecoveryHP][mapCaseData.Id].bFinish = false
|
||
elseif mapCaseData.HawkerCase ~= nil then
|
||
print("HawkerCase")
|
||
local nType = self.nRoomType
|
||
local mapStarTower = ConfigTable.GetData("StarTower", self.nTowerId)
|
||
local nNpcId = mapStarTower.ShopNpc
|
||
if nType ~= GameEnum.starTowerRoomType.ShopRoom then
|
||
nNpcId = mapStarTower.StandShopNpc
|
||
end
|
||
self.mapNpc[nNpcId] = mapCaseData.Id
|
||
self.mapCases[self.EnumCase.Hawker] = mapCaseData.HawkerCase
|
||
self.mapCases[self.EnumCase.Hawker].Id = mapCaseData.Id
|
||
self.mapCases[self.EnumCase.Hawker].nNpc = nNpcId
|
||
self.mapCases[self.EnumCase.Hawker].bFinish = false
|
||
elseif mapCaseData.StrengthenMachineCase ~= nil then
|
||
print("StrengthenMachineCase")
|
||
local mapStarTower = ConfigTable.GetData("StarTower", self.nTowerId)
|
||
local nNpcId = mapStarTower.UpgradeNpc
|
||
self.mapNpc[nNpcId] = mapCaseData.Id
|
||
self.mapCases[self.EnumCase.StrengthenMachine] = mapCaseData.StrengthenMachineCase
|
||
self.mapCases[self.EnumCase.StrengthenMachine].Id = mapCaseData.Id
|
||
self.mapCases[self.EnumCase.StrengthenMachine].bFinish = false
|
||
elseif mapCaseData.SyncHPCase ~= nil then
|
||
self.mapCases[self.EnumCase.SyncHP] = mapCaseData.Id
|
||
end
|
||
end
|
||
end
|
||
function StarTowerSweepData:SaveSelectResp(mapCaseData, nCaseId)
|
||
if not mapCaseData or not nCaseId then
|
||
return
|
||
end
|
||
if mapCaseData.SelectPotentialCase ~= nil then
|
||
self.mapCases[self.EnumCase.PotentialSelect][nCaseId] = mapCaseData.SelectPotentialCase
|
||
self.mapCases[self.EnumCase.PotentialSelect][nCaseId].bFinish = false
|
||
self.mapCases[self.EnumCase.PotentialSelect][nCaseId].bReRoll = true
|
||
elseif mapCaseData.SelectSpecialPotentialCase ~= nil then
|
||
self.mapCases[self.EnumCase.SelectSpecialPotential][nCaseId] = mapCaseData.SelectSpecialPotentialCase
|
||
self.mapCases[self.EnumCase.SelectSpecialPotential][nCaseId].bFinish = false
|
||
self.mapCases[self.EnumCase.SelectSpecialPotential][nCaseId].bReRoll = true
|
||
elseif mapCaseData.SelectFateCardCase ~= nil then
|
||
self.mapCases[self.EnumCase.FateCardSelect][nCaseId] = mapCaseData.SelectFateCardCase
|
||
self.mapCases[self.EnumCase.FateCardSelect][nCaseId].bFinish = false
|
||
self.mapCases[self.EnumCase.FateCardSelect][nCaseId].bReRoll = true
|
||
elseif mapCaseData.HawkerCase ~= nil then
|
||
local temp = self.mapCases[self.EnumCase.Hawker]
|
||
self.mapCases[self.EnumCase.Hawker] = mapCaseData.HawkerCase
|
||
self.mapCases[self.EnumCase.Hawker].bFinish = false
|
||
self.mapCases[self.EnumCase.Hawker].bReRoll = true
|
||
self.mapCases[self.EnumCase.Hawker].Id = temp.Id
|
||
self.mapCases[self.EnumCase.Hawker].nNpc = temp.nNpcId
|
||
end
|
||
end
|
||
function StarTowerSweepData:StarTowerInteract(mapMsgData, callback)
|
||
if self.bEnd then
|
||
return
|
||
end
|
||
local NetCallback = function(_, mapNetData)
|
||
local mapChangeNote, mapChangeSecondarySkill = self:ProcessTowerChangeData(mapNetData.Data)
|
||
local tbChangeFateCard, mapItemChange, mapPotentialChange = self:ProcessChangeInfo(mapNetData.Change)
|
||
local nExpChange = 0
|
||
local nLevelChange = 0
|
||
EventManager.Hit("RefreshNoteCount", self._mapNote, mapChangeNote, mapChangeSecondarySkill)
|
||
if mapNetData.BattleEndResp ~= nil and mapNetData.BattleEndResp.Victory ~= nil then
|
||
nExpChange = mapNetData.BattleEndResp.Victory.Exp - self.nTeamExp
|
||
nLevelChange = mapNetData.BattleEndResp.Victory.Lv - self.nTeamLevel
|
||
self.nTeamLevel = mapNetData.BattleEndResp.Victory.Lv
|
||
self.nTeamExp = mapNetData.BattleEndResp.Victory.Exp
|
||
self.nRankBattleTime = self.nRankBattleTime + mapNetData.BattleEndResp.Victory.BattleTime
|
||
end
|
||
EventManager.Hit("RefreshFastBattleInfo", tbChangeFateCard, mapChangeNote, mapItemChange, nLevelChange, nExpChange, mapPotentialChange)
|
||
self:SaveCase(mapNetData.Cases)
|
||
self:SaveSelectResp(mapNetData.SelectResp, mapMsgData.Id)
|
||
if callback ~= nil and type(callback) == "function" then
|
||
callback(mapNetData, tbChangeFateCard, mapChangeNote, mapItemChange, nLevelChange, nExpChange, mapPotentialChange)
|
||
end
|
||
end
|
||
HttpNetHandler.SendMsg(NetMsgId.Id.star_tower_interact_req, mapMsgData, nil, NetCallback)
|
||
end
|
||
function StarTowerSweepData:EnterRoom(nCaseId, nRoomType)
|
||
if self.nCurLevel + 1 > #self.tbStarTowerAllLevel then
|
||
self:StarTowerClear(nCaseId)
|
||
return
|
||
end
|
||
local floorId = 0
|
||
local sExData = ""
|
||
local scenePrefabId = 0
|
||
self.nRoomType = nRoomType
|
||
if nRoomType ~= GameEnum.starTowerRoomType.DangerRoom and nRoomType ~= GameEnum.starTowerRoomType.HorrorRoom then
|
||
self.nCurLevel = self.nCurLevel + 1
|
||
end
|
||
local NetCallback = function(_, mapNetData)
|
||
if mapNetData.EnterResp == nil then
|
||
printError("�������ݷ���Ϊ��")
|
||
return
|
||
end
|
||
self:ProcessChangeInfo(mapNetData.Change)
|
||
self:InitRoom(mapNetData.EnterResp.Room.Cases)
|
||
EventManager.Hit("InitRoom")
|
||
end
|
||
local EnterReq = {
|
||
MapId = self.curMapId,
|
||
ParamId = floorId,
|
||
DateLen = 0,
|
||
ClientData = "",
|
||
MapParam = sExData,
|
||
MapTableId = scenePrefabId
|
||
}
|
||
local mapMsg = {Id = nCaseId, EnterReq = EnterReq}
|
||
HttpNetHandler.SendMsg(NetMsgId.Id.star_tower_interact_req, mapMsg, nil, NetCallback)
|
||
end
|
||
function StarTowerSweepData:StarTowerLeave()
|
||
local nRecon = PlayerData.State:GetStarTowerRecon()
|
||
local mapStateInfo = {
|
||
Id = self.nTowerId,
|
||
ReConnection = nRecon,
|
||
BuildId = 0,
|
||
CharIds = self.tbTeam,
|
||
Floor = self.nCurLevel,
|
||
Sweep = true
|
||
}
|
||
PlayerData.State:CacheStarTowerStateData(mapStateInfo)
|
||
end
|
||
function StarTowerSweepData:StarTowerClear(nCaseId)
|
||
local EnterReq = {MapId = 0}
|
||
local mapMsg = {Id = nCaseId, EnterReq = EnterReq}
|
||
local NetCallback = function(_, mapNetMsg)
|
||
local mapBuildInfo
|
||
local mapChangeInfo = {}
|
||
local tbRes = {}
|
||
local tbItem = {}
|
||
local nTime = 0
|
||
local mapNpcAffinity = {}
|
||
local tbTowerRewards = {}
|
||
if mapNetMsg.Settle ~= nil then
|
||
PlayerData.StarTower:CacheNpcAffinityChange(mapNetMsg.Settle.Reward, mapNetMsg.Settle.NpcInteraction)
|
||
mapBuildInfo = mapNetMsg.Settle.Build
|
||
mapChangeInfo = mapNetMsg.Settle.Change
|
||
nTime = mapNetMsg.Settle.TotalTime
|
||
mapNpcAffinity = mapNetMsg.Settle.Reward
|
||
tbTowerRewards = mapNetMsg.Settle.TowerRewards
|
||
end
|
||
if mapChangeInfo ~= nil then
|
||
local encodeInfo = UTILS.DecodeChangeInfo(mapChangeInfo)
|
||
if encodeInfo["proto.Res"] ~= nil then
|
||
for _, mapCoin in ipairs(encodeInfo["proto.Res"]) do
|
||
table.insert(tbRes, {
|
||
nTid = mapCoin.Tid,
|
||
nCount = mapCoin.Qty
|
||
})
|
||
if mapCoin.Tid == AllEnum.CoinItemId.FRRewardCurrency then
|
||
PlayerData.StarTower:AddStarTowerTicket(mapCoin.Qty)
|
||
end
|
||
end
|
||
end
|
||
if encodeInfo["proto.Item"] ~= nil then
|
||
for _, mapItem in ipairs(encodeInfo["proto.Item"]) do
|
||
local mapItemConfigData = ConfigTable.GetData_Item(mapItem.Tid)
|
||
if mapItemConfigData == nil then
|
||
return
|
||
end
|
||
if mapItemConfigData.Stype ~= GameEnum.itemStype.Res then
|
||
table.insert(tbItem, {
|
||
nTid = mapItem.Tid,
|
||
nCount = mapItem.Qty
|
||
})
|
||
end
|
||
end
|
||
end
|
||
end
|
||
local nPotentialCount = 0
|
||
for _, mapPotential in pairs(self._mapPotential) do
|
||
for _, nCount in pairs(mapPotential) do
|
||
nPotentialCount = nPotentialCount + nCount
|
||
end
|
||
end
|
||
local mapResult = {
|
||
nRoguelikeId = self.nTowerId,
|
||
tbDisc = self.tbDisc,
|
||
tbRes = tbRes,
|
||
tbPresents = {},
|
||
tbOutfit = {},
|
||
tbItem = tbItem,
|
||
tbRarityCount = {},
|
||
bSuccess = true,
|
||
nFloor = self.nCurLevel,
|
||
nStage = self.tbStarTowerAllLevel[self.nCurLevel].Id,
|
||
mapBuild = mapBuildInfo,
|
||
nExp = 0,
|
||
nPerkCount = nPotentialCount,
|
||
tbBonus = {},
|
||
nTime = nTime,
|
||
tbAffinities = {},
|
||
mapChangeInfo = mapChangeInfo,
|
||
bRanking = self.bRanking,
|
||
mapNPCAffinity = mapNpcAffinity,
|
||
tbRewards = tbTowerRewards,
|
||
bSweep = true
|
||
}
|
||
EventManager.Hit(EventId.OpenPanel, PanelId.StarTowerResult, mapResult, self.tbTeam)
|
||
local wait = function()
|
||
coroutine.yield(CS.UnityEngine.WaitForEndOfFrame())
|
||
EventManager.Hit(EventId.ClosePanel, PanelId.StarTowerFastBattle)
|
||
end
|
||
cs_coroutine.start(wait)
|
||
PlayerData.State:CacheStarTowerStateData(nil)
|
||
end
|
||
HttpNetHandler.SendMsg(NetMsgId.Id.star_tower_interact_req, mapMsg, nil, NetCallback)
|
||
end
|
||
function StarTowerSweepData:ProcessChangeInfo(mapChangeData)
|
||
local mapData = UTILS.DecodeChangeInfo(mapChangeData)
|
||
local tbChangeFateCard = {}
|
||
local mapRewardChange = {}
|
||
local mapPotentialChange = {}
|
||
if mapData["proto.FateCardInfo"] ~= nil then
|
||
for _, mapFateCardData in ipairs(mapData["proto.FateCardInfo"]) do
|
||
local nBeforeRoomCount = 0
|
||
local nBeforeEftCount = 0
|
||
if self._mapFateCard[mapFateCardData.Tid] ~= nil then
|
||
nBeforeRoomCount = self._mapFateCard[mapFateCardData.Tid][2]
|
||
nBeforeEftCount = self._mapFateCard[mapFateCardData.Tid][1]
|
||
end
|
||
if mapFateCardData.Qty == 0 then
|
||
self._mapFateCard[mapFateCardData.Tid] = nil
|
||
table.insert(tbChangeFateCard, {
|
||
mapFateCardData.Tid,
|
||
0,
|
||
0,
|
||
-1
|
||
})
|
||
else
|
||
local nCountSum = 0
|
||
if self._mapFateCard[mapFateCardData.Tid] == nil then
|
||
nCountSum = 1
|
||
elseif mapFateCardData.Room ~= 0 and mapFateCardData.Remain ~= 0 then
|
||
local nBeforeCount = math.max(nBeforeEftCount, nBeforeRoomCount)
|
||
if self._mapFateCard[mapFateCardData.Tid] ~= nil and nBeforeCount <= 0 then
|
||
nCountSum = 2
|
||
end
|
||
end
|
||
self._mapFateCard[mapFateCardData.Tid] = {
|
||
mapFateCardData.Remain,
|
||
mapFateCardData.Room
|
||
}
|
||
table.insert(tbChangeFateCard, {
|
||
mapFateCardData.Tid,
|
||
self._mapFateCard[mapFateCardData.Tid][1] - nBeforeEftCount,
|
||
self._mapFateCard[mapFateCardData.Tid][2] - nBeforeRoomCount,
|
||
nCountSum
|
||
})
|
||
end
|
||
end
|
||
end
|
||
if mapData["proto.PotentialInfo"] ~= nil then
|
||
for _, mapPotentialInfo in ipairs(mapData["proto.PotentialInfo"]) do
|
||
local mapPotentialCfgData = ConfigTable.GetData("Potential", mapPotentialInfo.Tid)
|
||
if mapPotentialCfgData == nil then
|
||
printError("PotentialCfgData Missing" .. mapPotentialInfo.Tid)
|
||
else
|
||
local nCharId = mapPotentialCfgData.CharId
|
||
if self._mapPotential[nCharId][mapPotentialInfo.Tid] == nil then
|
||
self._mapPotential[nCharId][mapPotentialInfo.Tid] = 0
|
||
end
|
||
local nCurLevel = self._mapPotential[nCharId][mapPotentialInfo.Tid]
|
||
local nNextLevel = self._mapPotential[nCharId][mapPotentialInfo.Tid] + mapPotentialInfo.Level
|
||
mapPotentialChange[mapPotentialInfo.Tid] = {nLevel = nCurLevel, nNextLevel = nNextLevel}
|
||
self._mapPotential[nCharId][mapPotentialInfo.Tid] = nNextLevel
|
||
end
|
||
end
|
||
end
|
||
if mapData["proto.TowerItemInfo"] ~= nil then
|
||
for _, mapItemInfo in ipairs(mapData["proto.TowerItemInfo"]) do
|
||
if self._mapItem[mapItemInfo.Tid] == nil then
|
||
self._mapItem[mapItemInfo.Tid] = 0
|
||
end
|
||
self._mapItem[mapItemInfo.Tid] = self._mapItem[mapItemInfo.Tid] + mapItemInfo.Qty
|
||
if mapRewardChange[mapItemInfo.Tid] == nil then
|
||
mapRewardChange[mapItemInfo.Tid] = mapItemInfo.Qty
|
||
else
|
||
mapRewardChange[mapItemInfo.Tid] = mapRewardChange[mapItemInfo.Tid] + mapItemInfo.Qty
|
||
end
|
||
end
|
||
end
|
||
if mapData["proto.TowerResInfo"] ~= nil then
|
||
for _, mapItemInfo in ipairs(mapData["proto.TowerResInfo"]) do
|
||
if self._mapItem[mapItemInfo.Tid] == nil then
|
||
self._mapItem[mapItemInfo.Tid] = 0
|
||
end
|
||
self._mapItem[mapItemInfo.Tid] = self._mapItem[mapItemInfo.Tid] + mapItemInfo.Qty
|
||
if mapRewardChange[mapItemInfo.Tid] == nil then
|
||
mapRewardChange[mapItemInfo.Tid] = mapItemInfo.Qty
|
||
else
|
||
mapRewardChange[mapItemInfo.Tid] = mapRewardChange[mapItemInfo.Tid] + mapItemInfo.Qty
|
||
end
|
||
end
|
||
end
|
||
return tbChangeFateCard, mapRewardChange, mapPotentialChange
|
||
end
|
||
function StarTowerSweepData:ProcessTowerChangeData(mapChange)
|
||
if not mapChange then
|
||
return {}, {}
|
||
end
|
||
local mapChangeNote = {}
|
||
if mapChange.Infos and next(mapChange.Infos) ~= nil then
|
||
for _, mapNoteInfo in ipairs(mapChange.Infos) do
|
||
print(string.format("���������仯��%d,%d", mapNoteInfo.Tid, mapNoteInfo.Qty))
|
||
if self._mapNote[mapNoteInfo.Tid] == nil then
|
||
self._mapNote[mapNoteInfo.Tid] = 0
|
||
end
|
||
self._mapNote[mapNoteInfo.Tid] = self._mapNote[mapNoteInfo.Tid] + mapNoteInfo.Qty
|
||
mapChangeNote[mapNoteInfo.Tid] = mapNoteInfo
|
||
end
|
||
end
|
||
local mapChangeSecondarySkill = {}
|
||
if mapChange.Secondaries and next(mapChange.Secondaries) ~= nil then
|
||
for _, v in ipairs(mapChange.Secondaries) do
|
||
table.insert(mapChangeSecondarySkill, v)
|
||
if v.Active then
|
||
table.insert(self.tbActiveSecondaryIds, v.SecondaryId)
|
||
else
|
||
table.removebyvalue(self.tbActiveSecondaryIds, v.SecondaryId)
|
||
end
|
||
end
|
||
end
|
||
return mapChangeNote, mapChangeSecondarySkill
|
||
end
|
||
function StarTowerSweepData:HandleNpc(nNpcId, nNpcUid)
|
||
if self.blockNpcBtn then
|
||
return
|
||
end
|
||
local nCaseId = self.mapNpc[nNpcId]
|
||
if nCaseId == nil then
|
||
printError("Npcû�ж�Ӧ�¼�ID:" .. nNpcId)
|
||
return
|
||
end
|
||
local mapNpcCfgData = ConfigTable.GetData("NPCConfig", nNpcId)
|
||
if mapNpcCfgData == nil then
|
||
printError("Npc config missing:" .. nNpcId)
|
||
return
|
||
end
|
||
if mapNpcCfgData.type == GameEnum.npcNewType.Narrate then
|
||
local tbChat = ConfigTable.GetData("NPCConfig", nNpcId).Lines
|
||
local nTalkId = tbChat[math.random(1, #tbChat)]
|
||
if nTalkId == nil then
|
||
nTalkId = 0
|
||
end
|
||
local nBoardNpcId = ConfigTable.GetData("NPCConfig", nNpcId).NPCId
|
||
local nSkinId = PlayerData.Board:GetNPCUsingSkinId(nBoardNpcId)
|
||
local nCoin = self._mapItem[AllEnum.CoinItemId.FixedRogCurrency] or 0
|
||
EventManager.Hit(EventId.OpenPanel, PanelId.NpcOptionPanel, 0, 0, {}, nSkinId, 1, {}, {}, nTalkId, 0, true, true, nCoin, self.nTowerId, self._mapNote, self.tbDisc)
|
||
return
|
||
elseif mapNpcCfgData.type == GameEnum.npcNewType.Event then
|
||
self:OpenNpcOptionPanel(nCaseId, nNpcId)
|
||
return
|
||
elseif mapNpcCfgData.type == GameEnum.npcNewType.Resque then
|
||
self:HandleNpcRecover(nCaseId, nNpcId)
|
||
return
|
||
elseif mapNpcCfgData.type == GameEnum.npcNewType.Danger then
|
||
self:HandleNpcDangerRoom(nCaseId, nNpcId)
|
||
return
|
||
elseif mapNpcCfgData.type == GameEnum.npcNewType.Horror then
|
||
self:HandleNpcDangerRoom(nCaseId, nNpcId)
|
||
return
|
||
elseif mapNpcCfgData.type == GameEnum.npcNewType.Shop then
|
||
self:InteractiveShop(nCaseId, nNpcId)
|
||
return
|
||
elseif mapNpcCfgData.type == GameEnum.npcNewType.Upgrade then
|
||
self:InteractiveStrengthMachine(nCaseId, nNpcId)
|
||
return
|
||
else
|
||
printError("�������¼�")
|
||
end
|
||
printError("û���ҵ��ɽ������¼�:" .. nNpcId)
|
||
end
|
||
function StarTowerSweepData:HandleCases()
|
||
if self.mapCases[self.EnumCase.Battle] ~= nil and self.mapCases[self.EnumCase.Battle].bFinish ~= true then
|
||
local msg = {}
|
||
local nEventId = self.mapCases[self.EnumCase.Battle].Id
|
||
msg.Id = nEventId
|
||
msg.BattleEndReq = {}
|
||
msg.BattleEndReq.Victory = {
|
||
HP = 0,
|
||
Time = 0,
|
||
ClientData = "",
|
||
fateCardUsage = {},
|
||
DateLen = 0,
|
||
Damages = {},
|
||
Sample = {},
|
||
Events = {
|
||
List = {}
|
||
}
|
||
}
|
||
local callback = function(callbackMsg)
|
||
if callbackMsg ~= nil and callbackMsg.SelectResp ~= nil then
|
||
self.mapCases[self.EnumCase.Battle].bFinish = callbackMsg.SelectResp.Resp.OptionsResult
|
||
else
|
||
self.mapCases[self.EnumCase.Battle].bFinish = true
|
||
end
|
||
self:HandleCases()
|
||
end
|
||
self:StarTowerInteract(msg, callback)
|
||
return
|
||
end
|
||
if self.tbPopup[self.EnumPopup.StrengthFx] ~= nil then
|
||
for _, mapData in ipairs(self.tbPopup[self.EnumPopup.StrengthFx]) do
|
||
if not mapData.bFinish then
|
||
self:HandleShopStrengthFx(mapData)
|
||
return
|
||
end
|
||
end
|
||
end
|
||
if self.tbPopup[self.EnumPopup.Potential] ~= nil then
|
||
for _, mapData in ipairs(self.tbPopup[self.EnumPopup.Potential]) do
|
||
if not mapData.bFinish then
|
||
self:HandlePopupPotential(mapData)
|
||
return
|
||
end
|
||
end
|
||
end
|
||
if self.tbPopup[self.EnumPopup.Reward] ~= nil then
|
||
for _, mapData in ipairs(self.tbPopup[self.EnumPopup.Reward]) do
|
||
if not mapData.bFinish then
|
||
self:HandlePopupReward(mapData)
|
||
return
|
||
end
|
||
end
|
||
end
|
||
if self.mapCases[self.EnumCase.RecoveryHP] ~= nil then
|
||
for nId, mapData in pairs(self.mapCases[self.EnumCase.RecoveryHP]) do
|
||
if mapData.bFinish ~= true then
|
||
self:HandleRecover(nId)
|
||
return
|
||
end
|
||
end
|
||
end
|
||
if self.mapCases[self.EnumCase.SelectSpecialPotential] ~= nil then
|
||
for nId, mapData in pairs(self.mapCases[self.EnumCase.SelectSpecialPotential]) do
|
||
if mapData.bFinish ~= true then
|
||
self:OpenSelectPotential(nId, true)
|
||
return
|
||
end
|
||
end
|
||
end
|
||
if self.mapCases[self.EnumCase.PotentialSelect] ~= nil then
|
||
for nId, mapData in pairs(self.mapCases[self.EnumCase.PotentialSelect]) do
|
||
if mapData.bFinish ~= true then
|
||
self:OpenSelectPotential(nId)
|
||
return
|
||
end
|
||
end
|
||
end
|
||
if self.mapCases[self.EnumCase.NoteSelect] ~= nil then
|
||
for nId, mapData in pairs(self.mapCases[self.EnumCase.NoteSelect]) do
|
||
if mapData.bFinish ~= true then
|
||
self:OpenSelectNote(nId)
|
||
return
|
||
end
|
||
end
|
||
end
|
||
if self.mapCases[self.EnumCase.FateCardSelect] ~= nil then
|
||
for nId, mapData in pairs(self.mapCases[self.EnumCase.FateCardSelect]) do
|
||
if mapData.bFinish ~= true then
|
||
self:OpenSelectFateCard(nId)
|
||
return
|
||
end
|
||
end
|
||
end
|
||
if self.tbPopup[self.EnumPopup.Disc] ~= nil then
|
||
for _, mapData in ipairs(self.tbPopup[self.EnumPopup.Disc]) do
|
||
if not mapData.bFinish then
|
||
self:HandlePopupDisc(mapData)
|
||
return
|
||
end
|
||
end
|
||
end
|
||
if self.mapCases[self.EnumCase.NpcEvent] ~= nil then
|
||
for nId, mapData in pairs(self.mapCases[self.EnumCase.NpcEvent]) do
|
||
if mapData.bFinish ~= true then
|
||
self:HandleNpc(mapData.NPCId)
|
||
return
|
||
end
|
||
end
|
||
end
|
||
if self.mapCases[self.EnumCase.DoorDanger] ~= nil then
|
||
for nId, mapData in pairs(self.mapCases[self.EnumCase.DoorDanger]) do
|
||
if mapData.bFinish ~= true then
|
||
self:HandleNpc(mapData.NpcId)
|
||
mapData.bFinish = true
|
||
return
|
||
end
|
||
end
|
||
end
|
||
EventManager.Hit("EventHandleOver")
|
||
return false
|
||
end
|
||
function StarTowerSweepData:OpenSelectPotential(nCaseId, bSpecial)
|
||
local ProcessSpecialPotentialData = function(nId)
|
||
local mapCaseData = self.mapCases[self.EnumCase.SelectSpecialPotential][nId]
|
||
local tbPotential = {}
|
||
local mapPotential = {}
|
||
for _, nPotentialId in ipairs(mapCaseData.Ids) do
|
||
table.insert(tbPotential, {Id = nPotentialId, Count = 1})
|
||
mapPotential[nPotentialId] = 0
|
||
local mapPotentialCfgData = ConfigTable.GetData("Potential", nPotentialId)
|
||
if mapPotentialCfgData == nil then
|
||
printError("PotentialCfgData Missing" .. nPotentialId)
|
||
return
|
||
end
|
||
local nCharId = mapPotentialCfgData.CharId
|
||
if self._mapPotential[nCharId][nPotentialId] ~= nil then
|
||
mapPotential[nPotentialId] = self._mapPotential[nCharId][nPotentialId]
|
||
end
|
||
end
|
||
local nType = 0
|
||
if 0 < mapCaseData.TeamLevel then
|
||
nType = 1
|
||
end
|
||
local mapRoll = {
|
||
CanReRoll = mapCaseData.CanReRoll,
|
||
ReRollPrice = mapCaseData.ReRollPrice
|
||
}
|
||
return tbPotential, mapPotential, nType, mapCaseData.TeamLevel, mapCaseData.NewIds, mapRoll
|
||
end
|
||
local ProcessPotentialData = function(nId)
|
||
local mapCaseData = self.mapCases[self.EnumCase.PotentialSelect][nId]
|
||
local tbPotential = {}
|
||
local mapPotential = {}
|
||
for _, mapPotentialInfo in ipairs(mapCaseData.Infos) do
|
||
table.insert(tbPotential, {
|
||
Id = mapPotentialInfo.Tid,
|
||
Count = mapPotentialInfo.Level
|
||
})
|
||
mapPotential[mapPotentialInfo.Tid] = 0
|
||
local mapPotentialCfgData = ConfigTable.GetData("Potential", mapPotentialInfo.Tid)
|
||
if mapPotentialCfgData == nil then
|
||
printError("PotentialCfgData Missing" .. mapPotentialInfo.Tid)
|
||
return
|
||
end
|
||
local nCharId = mapPotentialCfgData.CharId
|
||
if self._mapPotential[nCharId][mapPotentialInfo.Tid] ~= nil then
|
||
mapPotential[mapPotentialInfo.Tid] = self._mapPotential[nCharId][mapPotentialInfo.Tid]
|
||
end
|
||
end
|
||
local mapRoll = {
|
||
CanReRoll = mapCaseData.CanReRoll,
|
||
ReRollPrice = mapCaseData.ReRollPrice
|
||
}
|
||
return tbPotential, mapPotential, mapCaseData.Type, mapCaseData.TeamLevel, mapCaseData.NewIds, mapRoll, mapCaseData.LuckyIds
|
||
end
|
||
local GetUnfinishedSelect = function()
|
||
if self.mapCases[self.EnumCase.SelectSpecialPotential] ~= nil then
|
||
for nId, mapData in pairs(self.mapCases[self.EnumCase.SelectSpecialPotential]) do
|
||
if mapData.bFinish ~= true then
|
||
local tbPotential, mapPotential, nType, nLevel, tbNewIds, mapRoll = ProcessSpecialPotentialData(nId)
|
||
return nId, tbPotential, mapPotential, nType, nLevel, tbNewIds, mapRoll
|
||
end
|
||
end
|
||
end
|
||
if self.mapCases[self.EnumCase.PotentialSelect] ~= nil then
|
||
for nId, mapData in pairs(self.mapCases[self.EnumCase.PotentialSelect]) do
|
||
if mapData.bFinish ~= true then
|
||
local tbPotential, mapPotential, nType, nLevel, tbNewIds, mapRoll, tbLuckyIds = ProcessPotentialData(nId)
|
||
return nId, tbPotential, mapPotential, nType, nLevel, tbNewIds, mapRoll, tbLuckyIds
|
||
end
|
||
end
|
||
end
|
||
return 0, {}, {}, 0
|
||
end
|
||
local SelectCallback = function(nIdx, nId, panelCallback, bReRoll)
|
||
if nId == -1 then
|
||
local wait = function()
|
||
coroutine.yield(CS.UnityEngine.WaitForEndOfFrame())
|
||
coroutine.yield(CS.UnityEngine.WaitForEndOfFrame())
|
||
self:HandleCases()
|
||
end
|
||
cs_coroutine.start(wait)
|
||
return
|
||
end
|
||
local msg = {}
|
||
msg.Id = nId
|
||
msg.SelectReq = {}
|
||
if bReRoll then
|
||
msg.SelectReq.ReRoll = true
|
||
else
|
||
msg.SelectReq.Index = nIdx - 1
|
||
end
|
||
local InteractiveCallback = function(callbackMsg)
|
||
local Id = callbackMsg.Id
|
||
if self.mapCases[self.EnumCase.SelectSpecialPotential] ~= nil and self.mapCases[self.EnumCase.SelectSpecialPotential][Id] ~= nil then
|
||
if self.mapCases[self.EnumCase.SelectSpecialPotential][nId].bReRoll then
|
||
self.mapCases[self.EnumCase.SelectSpecialPotential][nId].bReRoll = false
|
||
else
|
||
self.mapCases[self.EnumCase.SelectSpecialPotential][Id].bFinish = true
|
||
end
|
||
end
|
||
if self.mapCases[self.EnumCase.PotentialSelect] ~= nil and self.mapCases[self.EnumCase.PotentialSelect][Id] ~= nil then
|
||
if self.mapCases[self.EnumCase.PotentialSelect][nId].bReRoll then
|
||
self.mapCases[self.EnumCase.PotentialSelect][nId].bReRoll = false
|
||
else
|
||
self.mapCases[self.EnumCase.PotentialSelect][Id].bFinish = true
|
||
end
|
||
end
|
||
local caseId, tbPotential, mapPotential, nType, nTeamLevel, tbNewIds, mapRoll, tbLuckyIds = GetUnfinishedSelect()
|
||
local nCoin = self._mapItem[AllEnum.CoinItemId.FixedRogCurrency] or 0
|
||
if panelCallback ~= nil and type(panelCallback) == "function" then
|
||
local tbRecommend = self:GetRecommondPotential(tbPotential)
|
||
panelCallback(caseId, tbPotential, mapPotential, nType, nTeamLevel, tbNewIds, mapRoll, nCoin, tbLuckyIds, tbRecommend)
|
||
end
|
||
end
|
||
self:StarTowerInteract(msg, InteractiveCallback)
|
||
end
|
||
local tbPotential, mapPotential, nType, nTeamLevel, tbNewIds, mapRoll, tbLuckyIds
|
||
if bSpecial then
|
||
tbPotential, mapPotential, nType, nTeamLevel, tbNewIds, mapRoll = ProcessSpecialPotentialData(nCaseId)
|
||
else
|
||
tbPotential, mapPotential, nType, nTeamLevel, tbNewIds, mapRoll, tbLuckyIds = ProcessPotentialData(nCaseId)
|
||
end
|
||
local nCoin = self._mapItem[AllEnum.CoinItemId.FixedRogCurrency] or 0
|
||
local tbRecommend = self:GetRecommondPotential(tbPotential)
|
||
EventManager.Hit("StarTowerPotentialSelect", nCaseId, tbPotential, mapPotential, nType, nTeamLevel, tbNewIds, SelectCallback, mapRoll, nCoin, tbLuckyIds, tbRecommend)
|
||
end
|
||
function StarTowerSweepData:OpenSelectNote(nCaseId)
|
||
local ProcessNoteData = function(nId)
|
||
local mapCaseData = self.mapCases[self.EnumCase.NoteSelect][nId]
|
||
local tbNoteSelect = mapCaseData.Info
|
||
local mapNote = self._mapNote
|
||
return tbNoteSelect, mapNote
|
||
end
|
||
local GetUnfinishedSelect = function()
|
||
if self.mapCases[self.EnumCase.NoteSelect] ~= nil then
|
||
for nId, mapData in pairs(self.mapCases[self.EnumCase.NoteSelect]) do
|
||
if mapData.bFinish ~= true then
|
||
local tbPotential, mapPotential = ProcessNoteData(nId)
|
||
return nId, tbPotential, mapPotential
|
||
end
|
||
end
|
||
end
|
||
return 0, {}, {}
|
||
end
|
||
local SelectCallback = function(nIdx, nId, panelCallback)
|
||
if nIdx == -1 then
|
||
local wait = function()
|
||
coroutine.yield(CS.UnityEngine.WaitForEndOfFrame())
|
||
coroutine.yield(CS.UnityEngine.WaitForEndOfFrame())
|
||
self:HandleCases()
|
||
end
|
||
cs_coroutine.start(wait)
|
||
return
|
||
end
|
||
local msg = {}
|
||
msg.Id = nId
|
||
msg.SelectReq = {}
|
||
msg.SelectReq.Index = nIdx - 1
|
||
local InteractiveCallback = function(callbackMsg)
|
||
local Id = callbackMsg.Id
|
||
if self.mapCases[self.EnumCase.NoteSelect] ~= nil and self.mapCases[self.EnumCase.NoteSelect][Id] ~= nil then
|
||
self.mapCases[self.EnumCase.NoteSelect][Id].bFinish = true
|
||
end
|
||
local caseId, tbNoteSelect, mapNote = GetUnfinishedSelect()
|
||
if panelCallback ~= nil and type(panelCallback) == "function" then
|
||
panelCallback(caseId, tbNoteSelect, mapNote)
|
||
end
|
||
end
|
||
self:StarTowerInteract(msg, InteractiveCallback)
|
||
end
|
||
local tbNoteSelect, mapNote = ProcessNoteData(nCaseId)
|
||
EventManager.Hit("StarTowerSelectNote", nCaseId, mapNote, tbNoteSelect, SelectCallback)
|
||
end
|
||
function StarTowerSweepData:OpenSelectFateCard(nCaseId)
|
||
local ProcessFateCard = function(nId)
|
||
local mapCaseData = self.mapCases[self.EnumCase.FateCardSelect][nId]
|
||
local tbFateCard = mapCaseData.Ids
|
||
local tbNewIds = mapCaseData.NewIds
|
||
local bReward = mapCaseData.Give
|
||
local mapRoll = {
|
||
CanReRoll = mapCaseData.CanReRoll,
|
||
ReRollPrice = mapCaseData.ReRollPrice
|
||
}
|
||
return tbFateCard, tbNewIds, mapRoll, bReward
|
||
end
|
||
local GetUnfinishedSelect = function()
|
||
if self.mapCases[self.EnumCase.FateCardSelect] ~= nil then
|
||
for nId, mapData in pairs(self.mapCases[self.EnumCase.FateCardSelect]) do
|
||
if mapData.bFinish ~= true then
|
||
local tbFateCard, tbNewIds, mapRoll, bReward = ProcessFateCard(nId)
|
||
return nId, tbFateCard, tbNewIds, mapRoll, bReward
|
||
end
|
||
end
|
||
end
|
||
return 0, {}, {}
|
||
end
|
||
local SelectCallback = function(nIdx, nId, panelCallback, bReRoll)
|
||
if nIdx == -1 then
|
||
local wait = function()
|
||
coroutine.yield(CS.UnityEngine.WaitForEndOfFrame())
|
||
coroutine.yield(CS.UnityEngine.WaitForEndOfFrame())
|
||
self:HandleCases()
|
||
end
|
||
cs_coroutine.start(wait)
|
||
return
|
||
end
|
||
local msg = {}
|
||
msg.Id = nId
|
||
msg.SelectReq = {}
|
||
if bReRoll then
|
||
msg.SelectReq.ReRoll = true
|
||
else
|
||
msg.SelectReq.Index = nIdx - 1
|
||
end
|
||
local InteractiveCallback = function(callbackMsg)
|
||
local Id = callbackMsg.Id
|
||
if self.mapCases[self.EnumCase.FateCardSelect] ~= nil and self.mapCases[self.EnumCase.FateCardSelect][nId] ~= nil then
|
||
if self.mapCases[self.EnumCase.FateCardSelect][nId].bReRoll then
|
||
self.mapCases[self.EnumCase.FateCardSelect][nId].bReRoll = false
|
||
else
|
||
self.mapCases[self.EnumCase.FateCardSelect][nId].bFinish = true
|
||
end
|
||
end
|
||
local caseId, tbFateCard, tbNewIds, mapRoll, bReward = GetUnfinishedSelect()
|
||
local nCoin = self._mapItem[AllEnum.CoinItemId.FixedRogCurrency] or 0
|
||
if panelCallback ~= nil and type(panelCallback) == "function" then
|
||
panelCallback(caseId, tbFateCard, tbNewIds, mapRoll, nCoin, bReward)
|
||
end
|
||
end
|
||
self:StarTowerInteract(msg, InteractiveCallback)
|
||
end
|
||
local tbFateCard, tbNewIds, mapRoll, bReward = ProcessFateCard(nCaseId)
|
||
local nCoin = self._mapItem[AllEnum.CoinItemId.FixedRogCurrency] or 0
|
||
EventManager.Hit("StarTowerSelectFateCard", nCaseId, tbFateCard, tbNewIds, SelectCallback, mapRoll, nCoin, bReward)
|
||
end
|
||
function StarTowerSweepData:OpenNpcOptionPanel(nCaseId, nNpcConfigId)
|
||
if self.mapCases[self.EnumCase.NpcEvent] == nil then
|
||
printError("No NpcOptionCase!")
|
||
return
|
||
end
|
||
local mapCase = self.mapCases[self.EnumCase.NpcEvent][nCaseId]
|
||
if mapCase == nil then
|
||
printError("No NpcOptionCase! :" .. nCaseId)
|
||
return
|
||
end
|
||
local nBoardNpcId = ConfigTable.GetData("NPCConfig", nNpcConfigId).NPCId
|
||
local nSkinId = PlayerData.Board:GetNPCUsingSkinId(nBoardNpcId)
|
||
if mapCase.bFinish then
|
||
local tbChat = ConfigTable.GetData("NPCConfig", nNpcConfigId).Lines
|
||
local nCount = #tbChat
|
||
local nTalkId = tbChat[1]
|
||
if 1 < nCount then
|
||
nTalkId = tbChat[math.random(1, #tbChat)]
|
||
end
|
||
if nTalkId == nil then
|
||
nTalkId = 0
|
||
end
|
||
local nCoin = self._mapItem[AllEnum.CoinItemId.FixedRogCurrency] or 0
|
||
EventManager.Hit(EventId.OpenPanel, PanelId.NpcOptionPanel, 0, 0, {}, nSkinId, 1, {}, {}, nTalkId, 0, true, true, nCoin, self.nTowerId, self._mapNote, self.tbDisc)
|
||
return
|
||
end
|
||
local tbOption = mapCase.Options
|
||
local tbUnabledOption = mapCase.FailedIdxes
|
||
local nTableEvtId = mapCase.EvtId
|
||
local nEventId = nCaseId
|
||
local callback = function(nIdx, nEvtId, bClose)
|
||
EventManager.Hit("InteractiveNpcFinish", nNpcConfigId)
|
||
if bClose then
|
||
self.mapCases[self.EnumCase.NpcEvent][nCaseId].bFinish = true
|
||
self:HandleCases()
|
||
return
|
||
end
|
||
local nOptionId = tbOption[nIdx]
|
||
local mapOptionData = ConfigTable.GetData("EventOptions", nOptionId)
|
||
local bJump = false
|
||
if mapOptionData ~= nil then
|
||
bJump = mapOptionData.IgnoreInterActive
|
||
else
|
||
printError("EventOptions Missing��" .. nOptionId)
|
||
end
|
||
if bJump then
|
||
self.mapCases[self.EnumCase.NpcEvent][nCaseId].bFinish = true
|
||
self:HandleCases()
|
||
return
|
||
end
|
||
local msg = {}
|
||
msg.Id = nEvtId
|
||
msg.SelectReq = {}
|
||
msg.SelectReq.Index = nIdx - 1
|
||
local InteractiveCallback = function(callbackMsg, tbChangeFateCard, mapChangeNote, mapItemChange, nLevelChange, nExpChange, mapPotentialChange)
|
||
local wait = function()
|
||
coroutine.yield(CS.UnityEngine.WaitForEndOfFrame())
|
||
coroutine.yield(CS.UnityEngine.WaitForEndOfFrame())
|
||
self:HandleCases()
|
||
end
|
||
local bSuccess = false
|
||
if callbackMsg.SelectResp ~= nil and callbackMsg.SelectResp.Resp ~= nil then
|
||
bSuccess = callbackMsg.SelectResp.Resp.OptionsResult
|
||
end
|
||
if bSuccess then
|
||
self.mapCases[self.EnumCase.NpcEvent][nCaseId].bFinish = true
|
||
local tbInfo = {}
|
||
for _, mapChange in ipairs(callbackMsg.SelectResp.Resp.AffinityChange) do
|
||
table.insert(tbInfo, {
|
||
NPCId = mapChange.NPCId,
|
||
Affinity = mapChange.Affinity
|
||
})
|
||
EventManager.Hit("ShowNPCAffinity", mapChange.NPCId, mapChange.Increase)
|
||
end
|
||
self.mapCases[self.EnumCase.NpcEvent][nCaseId].Infos = tbInfo
|
||
EventManager.Hit("StarTowerEventInteract", clone(mapChangeNote), clone(mapItemChange), clone(mapPotentialChange), clone(tbChangeFateCard), clone(mapChangeSecondarySkill))
|
||
cs_coroutine.start(wait)
|
||
else
|
||
EventManager.Hit(EventId.OpenMessageBox, ConfigTable.GetUIText("Startower_EventFailHint"))
|
||
table.insert(mapCase.FailedIdxes, nIdx - 1)
|
||
self:HandleNpc(nNpcConfigId)
|
||
end
|
||
if callbackMsg.SelectResp ~= nil and callbackMsg.SelectResp.Resp ~= nil and callbackMsg.SelectResp.Resp.OptionsParamId ~= nil and callbackMsg.SelectResp.Resp.OptionsParamId ~= 0 then
|
||
local sTextId = "EventResult_" .. tostring(callbackMsg.SelectResp.Resp.OptionsParamId)
|
||
local sResultHint = ConfigTable.GetUIText(sTextId)
|
||
EventManager.Hit(EventId.OpenMessageBox, sResultHint)
|
||
end
|
||
end
|
||
self:StarTowerInteract(msg, InteractiveCallback)
|
||
end
|
||
local mapAffinity = {}
|
||
for _, mapInfo in ipairs(mapCase.Infos) do
|
||
mapAffinity[mapInfo.NPCId] = mapInfo.Affinity
|
||
end
|
||
local tbLines = ConfigTable.GetData("NPCConfig", nNpcConfigId).FirstLines
|
||
local tbChat = {}
|
||
for _, nTalkId in ipairs(tbLines) do
|
||
local mapTalkCfg = ConfigTable.GetData("StarTowerTalk", nTalkId)
|
||
if mapTalkCfg ~= nil and mapAffinity[mapTalkCfg.NPCId] ~= nil then
|
||
local nAffinity = mapAffinity[mapTalkCfg.NPCId]
|
||
if #mapTalkCfg.Affinity == 2 and nAffinity ~= nil and nAffinity >= mapTalkCfg.Affinity[1] and nAffinity <= mapTalkCfg.Affinity[2] then
|
||
table.insert(tbChat, nTalkId)
|
||
end
|
||
end
|
||
end
|
||
if #tbChat < 1 then
|
||
table.insert(tbChat, tbLines[1])
|
||
end
|
||
local nCount = #tbChat
|
||
local nTalkId = tbChat[1]
|
||
if 1 < nCount then
|
||
nTalkId = tbChat[math.random(1, #tbChat)]
|
||
end
|
||
if nTalkId == nil then
|
||
nTalkId = 0
|
||
end
|
||
mapCase.bFirst = false
|
||
local nCoin = self._mapItem[AllEnum.CoinItemId.FixedRogCurrency] or 0
|
||
EventManager.Hit(EventId.OpenPanel, PanelId.NpcOptionPanel, 1, nEventId, tbOption, nSkinId, callback, tbUnabledOption, nTableEvtId, nTalkId, mapCase.nActionId, false, true, nCoin, self.nTowerId, self._mapNote, self.tbDisc)
|
||
end
|
||
function StarTowerSweepData:HandleRecover(nCaseId, nNpcConfigId)
|
||
if self.mapCases[self.EnumCase.RecoveryHP] == nil then
|
||
printError("No RecoveryHP!")
|
||
return
|
||
end
|
||
local mapCase = self.mapCases[self.EnumCase.RecoveryHP][nCaseId]
|
||
if mapCase == nil then
|
||
printError("No RecoveryHP! :" .. nCaseId)
|
||
return
|
||
end
|
||
if mapCase.bFinish then
|
||
printError("Event has finished! :" .. nCaseId)
|
||
return
|
||
end
|
||
local nHp = 0
|
||
local msg = {}
|
||
msg.Id = nCaseId
|
||
msg.RecoveryHPReq = {}
|
||
msg.RecoveryHPReq.Hp = nHp
|
||
local callback = function(_, msgData)
|
||
self.mapCases[self.EnumCase.RecoveryHP][nCaseId].bFinish = true
|
||
self:HandleCases()
|
||
end
|
||
self:StarTowerInteract(msg, callback)
|
||
end
|
||
function StarTowerSweepData:HandleNpcRecover(nCaseId, nNpcConfigId)
|
||
if self.mapCases[self.EnumCase.NpcRecoveryHP] == nil then
|
||
printError("No NpcOptionCase!")
|
||
return
|
||
end
|
||
local mapCase = self.mapCases[self.EnumCase.NpcRecoveryHP][nCaseId]
|
||
if mapCase == nil then
|
||
printError("No NpcOptionCase! :" .. nCaseId)
|
||
return
|
||
end
|
||
if mapCase.bFinish then
|
||
local nBoardNpcId = ConfigTable.GetData("NPCConfig", nNpcConfigId).NPCId
|
||
local nSkinId = PlayerData.Board:GetNPCUsingSkinId(nBoardNpcId)
|
||
local tbChat = ConfigTable.GetData("NPCConfig", nNpcConfigId).Lines
|
||
local nCount = #tbChat
|
||
local nTalkId = tbChat[1]
|
||
if 1 < nCount then
|
||
nTalkId = tbChat[math.random(1, #tbChat)]
|
||
end
|
||
if nTalkId == nil then
|
||
nTalkId = 0
|
||
end
|
||
local nCoin = self._mapItem[AllEnum.CoinItemId.FixedRogCurrency] or 0
|
||
EventManager.Hit(EventId.OpenPanel, PanelId.NpcOptionPanel, 0, 0, {}, nSkinId, 1, {}, {}, nTalkId, 0, true, true, nCoin, self.nTowerId, self._mapNote, self.tbDisc)
|
||
return
|
||
end
|
||
local nHp = 0
|
||
local msg = {}
|
||
msg.Id = nCaseId
|
||
msg.RecoveryHPReq = {}
|
||
msg.RecoveryHPReq.Hp = nHp
|
||
local callback = function(_, msgData)
|
||
EventManager.Hit(EventId.OpenMessageBox, ConfigTable.GetUIText("StarTower_NpcRecoverTips"))
|
||
EventManager.Hit("InteractiveNpcFinish", nNpcConfigId)
|
||
self.mapCases[self.EnumCase.NpcRecoveryHP][nCaseId].bFinish = true
|
||
self:HandleCases()
|
||
end
|
||
self:StarTowerInteract(msg, callback)
|
||
end
|
||
function StarTowerSweepData:HandleNpcDangerRoom(nCaseId, nNpcConfigId)
|
||
if self.mapCases[self.EnumCase.DoorDanger] == nil then
|
||
printError("No NpcOptionCase!")
|
||
return
|
||
end
|
||
local mapCase = self.mapCases[self.EnumCase.DoorDanger][nCaseId]
|
||
if mapCase == nil then
|
||
printError("No NpcOptionCase! :" .. nCaseId)
|
||
return
|
||
end
|
||
local nRoomType = mapCase.Type
|
||
local nBoardNpcId = ConfigTable.GetData("NPCConfig", nNpcConfigId).NPCId
|
||
local nSkinId = PlayerData.Board:GetNPCUsingSkinId(nBoardNpcId)
|
||
local callback = function(nIdx, nEvtId)
|
||
EventManager.Hit("InteractiveNpcFinish", nNpcConfigId)
|
||
if nIdx == 1 then
|
||
EventManager.Hit("SweepEnterDangerRoom", nEvtId, nRoomType)
|
||
else
|
||
self:HandleCases()
|
||
end
|
||
end
|
||
local tbChat = ConfigTable.GetData("NPCConfig", nNpcConfigId).Lines
|
||
local nTalkId = tbChat[math.random(1, #tbChat)]
|
||
if nTalkId == nil then
|
||
nTalkId = 0
|
||
end
|
||
local nCoin = self._mapItem[AllEnum.CoinItemId.FixedRogCurrency] or 0
|
||
EventManager.Hit(EventId.OpenPanel, PanelId.NpcOptionPanel, 2, nCaseId, {}, nSkinId, callback, {}, 0, nTalkId, 0, false, true, nCoin, self.nTowerId, self._mapNote, self.tbDisc)
|
||
end
|
||
function StarTowerSweepData:HandlePopupDisc(mapData)
|
||
local callback = function()
|
||
mapData.bFinish = true
|
||
self:HandleCases()
|
||
end
|
||
EventManager.Hit("StarTowerShowDiscSkill", mapData.param, clone(self._mapNote), callback)
|
||
end
|
||
function StarTowerSweepData:HandlePopupReward(mapData)
|
||
local callback = function()
|
||
mapData.bFinish = true
|
||
self:HandleCases()
|
||
end
|
||
EventManager.Hit("StarTowerShowReward", mapData.param, callback)
|
||
end
|
||
function StarTowerSweepData:HandlePopupPotential(mapData)
|
||
local callback = function()
|
||
mapData.bFinish = true
|
||
self:HandleCases()
|
||
end
|
||
EventManager.Hit("ShowPotentialLevelUp", mapData.param, callback)
|
||
end
|
||
function StarTowerSweepData:HandleShopStrengthFx(mapData)
|
||
local callback = function()
|
||
mapData.bFinish = true
|
||
self:HandleCases()
|
||
end
|
||
EventManager.Hit("ShowShopStrengthFx", mapData.param, callback)
|
||
end
|
||
function StarTowerSweepData:InteractiveShop(nCaseId, nNpcConfigId)
|
||
if self.mapCases[self.EnumCase.Hawker] == nil then
|
||
printError("No Hawker Case!")
|
||
return
|
||
end
|
||
local mapCase = self.mapCases[self.EnumCase.Hawker]
|
||
if mapCase == nil then
|
||
printError("No Hawker Case! :" .. nCaseId)
|
||
return
|
||
end
|
||
local BuildRollData = function(case)
|
||
return {
|
||
CanReRoll = case.CanReRoll,
|
||
ReRollPrice = case.ReRollPrice,
|
||
ReRollTimes = case.ReRollTimes
|
||
}
|
||
end
|
||
local BuildShopData = function(case)
|
||
local tbShopData = {}
|
||
for index, mapGood in ipairs(case.List) do
|
||
tbShopData[index] = {
|
||
Idx = mapGood.Idx,
|
||
bSoldOut = table.indexof(case.Purchase, mapGood.Sid) > 0,
|
||
Price = mapGood.Price,
|
||
nDiscount = mapGood.Discount,
|
||
nCharId = 0 < mapGood.CharPos and self.tbTeam[mapGood.CharPos] or 0,
|
||
nSid = mapGood.Sid,
|
||
nType = mapGood.Type,
|
||
nGoodsId = mapGood.GoodsId
|
||
}
|
||
end
|
||
return tbShopData
|
||
end
|
||
local BuyCallback = function(nEvtId, nSid, callback, bReRoll)
|
||
local msg = {}
|
||
msg.Id = nEvtId
|
||
msg.HawkerReq = {}
|
||
if bReRoll then
|
||
msg.HawkerReq.ReRoll = true
|
||
else
|
||
msg.HawkerReq.Sid = nSid
|
||
end
|
||
local InteractiveCallback = function(callbackMsg, tbChangeFateCard, mapChangeNote, mapItemChange, nLevelChange, nExpChange, mapPotentialChange)
|
||
if callback ~= nil and type(callback) == "function" then
|
||
local nBagCount = self._mapItem[AllEnum.CoinItemId.FixedRogCurrency] or 0
|
||
local mapInteractiveCase = self.mapCases[self.EnumCase.Hawker]
|
||
if mapInteractiveCase.bReRoll then
|
||
self.mapCases[self.EnumCase.Hawker].bReRoll = false
|
||
local mapRoll = BuildRollData(mapInteractiveCase)
|
||
local tbShopData = BuildShopData(mapInteractiveCase)
|
||
callback(nBagCount, tbShopData, mapRoll)
|
||
else
|
||
table.insert(mapInteractiveCase.Purchase, nSid)
|
||
callback(nBagCount)
|
||
end
|
||
end
|
||
EventManager.Hit("StarTowerShopInteract", mapChangeNote)
|
||
self:HandleCases()
|
||
end
|
||
self:StarTowerInteract(msg, InteractiveCallback)
|
||
end
|
||
local mapRoll = BuildRollData(mapCase)
|
||
local tbShopData = BuildShopData(mapCase)
|
||
local nCoin = self._mapItem[AllEnum.CoinItemId.FixedRogCurrency] or 0
|
||
EventManager.Hit(EventId.OpenPanel, PanelId.StarTowerShop, tbShopData, nCoin, BuyCallback, nCaseId, mapRoll, self.tbDisc, self._mapNote, self.nTowerId, self.nCurLevel)
|
||
end
|
||
function StarTowerSweepData:InteractiveStrengthMachine(nCaseId, nNpcConfigId)
|
||
if self.mapCases[self.EnumCase.StrengthenMachine] == nil then
|
||
printError("No StrengthMachine Case!")
|
||
return
|
||
end
|
||
local mapCase = self.mapCases[self.EnumCase.StrengthenMachine]
|
||
if mapCase == nil then
|
||
printError("No StrengthMachine Case! :" .. nCaseId)
|
||
return
|
||
end
|
||
local nCoin = self._mapItem[AllEnum.CoinItemId.FixedRogCurrency]
|
||
if nCoin == nil then
|
||
nCoin = 0
|
||
end
|
||
local nDiscount = mapCase.Discount
|
||
local bFirstFree = mapCase.FirstFree
|
||
local nCost = self.tbStrengthMachineCost[mapCase.Times + 1]
|
||
if nCost == nil then
|
||
nCost = self.tbStrengthMachineCost[#self.tbStrengthMachineCost]
|
||
end
|
||
nCost = nCost - nDiscount
|
||
if bFirstFree then
|
||
nCost = 0
|
||
end
|
||
if nCoin < nCost then
|
||
printError("Not Enough Coin!")
|
||
EventManager.Hit(EventId.OpenMessageBox, ConfigTable.GetUIText("StarTower_NotEnoughCoin"))
|
||
return
|
||
end
|
||
local InteractiveCallback = function(netmsgData)
|
||
if netmsgData.StrengthenMachineResp ~= nil and not netmsgData.StrengthenMachineResp.BuySucceed then
|
||
EventManager.Hit(EventId.OpenMessageBox, ConfigTable.GetUIText("StarTower_NoPotential"))
|
||
printError("û�п�ѡ��DZ��")
|
||
return
|
||
end
|
||
if bFirstFree then
|
||
mapCase.FirstFree = false
|
||
else
|
||
mapCase.Times = mapCase.Times + 1
|
||
end
|
||
self:HandleCases()
|
||
EventManager.Hit("InteractiveNpcFinish")
|
||
EventManager.Hit("RefreshStrengthMachineCost", mapCase.Times, mapCase.FirstFree)
|
||
end
|
||
local msg = {}
|
||
msg.Id = nCaseId
|
||
self:StarTowerInteract(msg, InteractiveCallback)
|
||
end
|
||
function StarTowerSweepData:CalBuildScore()
|
||
local nPotentialScore = 0
|
||
for _, tbPotentialInfo in pairs(self._mapPotential) do
|
||
for nPotentialId, nPotentialLevel in pairs(tbPotentialInfo) do
|
||
local mapPotentialCfgData = ConfigTable.GetData("Potential", nPotentialId)
|
||
if nil ~= mapPotentialCfgData and 0 < nPotentialLevel then
|
||
nPotentialScore = nPotentialScore + mapPotentialCfgData.BuildScore[nPotentialLevel]
|
||
end
|
||
end
|
||
end
|
||
local nDiscScore = 0
|
||
for k, nDiscId in ipairs(self.tbDisc) do
|
||
if 0 ~= nDiscId and k <= 3 then
|
||
nDiscScore = nDiscScore + PlayerData.Disc:GetDiscSkillScore(nDiscId, self._mapNote)
|
||
end
|
||
end
|
||
local nNoteScore = 0
|
||
for nNoteId, nNoteCount in pairs(self._mapNote) do
|
||
if 0 < nNoteCount then
|
||
local mapCfg = ConfigTable.GetData("SubNoteSkill", nNoteId)
|
||
if mapCfg and next(mapCfg.Scores) ~= nil then
|
||
local nMax = #mapCfg.Scores
|
||
local nLevel = nNoteCount > nMax and nMax or nNoteCount
|
||
nNoteScore = nNoteScore + mapCfg.Scores[nLevel]
|
||
end
|
||
end
|
||
end
|
||
return nPotentialScore + nDiscScore + nNoteScore
|
||
end
|
||
function StarTowerSweepData:GetDoorCase()
|
||
if self.mapCases[self.EnumCase.OpenDoor] ~= nil then
|
||
return self.mapCases[self.EnumCase.OpenDoor][1], self.mapCases[self.EnumCase.OpenDoor][2]
|
||
end
|
||
return nil
|
||
end
|
||
function StarTowerSweepData:GetShopAndMachine()
|
||
local bShop = self.mapCases[self.EnumCase.Hawker] ~= nil
|
||
local bMachine = self.mapCases[self.EnumCase.StrengthenMachine] ~= nil
|
||
local nMachineCount, nDiscount, bFirstFree = 0, 0, false
|
||
if bMachine then
|
||
nMachineCount = self.mapCases[self.EnumCase.StrengthenMachine].Times
|
||
nDiscount = self.mapCases[self.EnumCase.StrengthenMachine].Discount
|
||
bFirstFree = self.mapCases[self.EnumCase.StrengthenMachine].FirstFree
|
||
end
|
||
return bShop, bMachine, nMachineCount, nDiscount, bFirstFree
|
||
end
|
||
function StarTowerSweepData:OpenShop()
|
||
local mapShopCase = self.mapCases[self.EnumCase.Hawker]
|
||
if mapShopCase == nil then
|
||
return false
|
||
end
|
||
local nCaseId = mapShopCase.Id
|
||
self:InteractiveShop(nCaseId, mapShopCase.nNpc)
|
||
return true
|
||
end
|
||
function StarTowerSweepData:OpenStrengthMachine()
|
||
local mapStrengthMachine = self.mapCases[self.EnumCase.StrengthenMachine]
|
||
if mapStrengthMachine == nil then
|
||
return false
|
||
end
|
||
self:InteractiveStrengthMachine(mapStrengthMachine.Id, 0)
|
||
return true
|
||
end
|
||
function StarTowerSweepData:DiscSkillActive(tbParam)
|
||
if self.tbPopup[self.EnumPopup.Disc] == nil then
|
||
self.tbPopup[self.EnumPopup.Disc] = {}
|
||
end
|
||
table.insert(self.tbPopup[self.EnumPopup.Disc], {bFinish = false, param = tbParam})
|
||
end
|
||
function StarTowerSweepData:CheckLastShopRoom()
|
||
local bLastRoom = self.nCurLevel == #self.tbStarTowerAllLevel
|
||
return bLastRoom
|
||
end
|
||
function StarTowerSweepData:GetShopMinPrice()
|
||
local nMinPrice = -1
|
||
local mapCase = self.mapCases[self.EnumCase.Hawker]
|
||
if mapCase ~= nil then
|
||
for index, mapGood in ipairs(mapCase.List) do
|
||
local bSoldOut = table.indexof(mapCase.Purchase, mapGood.Sid) > 0
|
||
local nPrice = 0 < mapGood.Discount and mapGood.Discount or mapGood.Price
|
||
if (nMinPrice > nPrice or nMinPrice == -1) and not bSoldOut then
|
||
nMinPrice = nPrice
|
||
end
|
||
end
|
||
if mapCase.CanReRoll and 0 < mapCase.ReRollTimes then
|
||
nMinPrice = 0 < nMinPrice and math.min(nMinPrice, mapCase.ReRollPrice) or mapCase.ReRollPrice
|
||
end
|
||
end
|
||
return nMinPrice
|
||
end
|
||
function StarTowerSweepData:GetRecommondPotential(tbPotentialData)
|
||
local tbPotential = {}
|
||
for _, mapData in ipairs(tbPotentialData) do
|
||
table.insert(tbPotential, mapData.Id)
|
||
end
|
||
if self.mapPreselectionData ~= nil then
|
||
local tbRecommend = {}
|
||
for k, v in ipairs(self.mapPreselectionData.tbCharPotential) do
|
||
if k == 1 then
|
||
if self.tbTeam[k] == v.nCharId then
|
||
for _, potential in ipairs(v.tbPotential) do
|
||
if table.indexof(tbPotential, potential.nId) > 0 then
|
||
table.insert(tbRecommend, {
|
||
nId = potential.nId,
|
||
nLevel = potential.nLevel
|
||
})
|
||
end
|
||
end
|
||
end
|
||
elseif 1 < table.indexof(self.tbTeam, v.nCharId) then
|
||
for _, potential in ipairs(v.tbPotential) do
|
||
if table.indexof(tbPotential, potential.nId) > 0 then
|
||
table.insert(tbRecommend, {
|
||
nId = potential.nId,
|
||
nLevel = potential.nLevel
|
||
})
|
||
end
|
||
end
|
||
end
|
||
end
|
||
return tbRecommend
|
||
end
|
||
local ret = {}
|
||
local curRarity = 999
|
||
for _, nPotentialId in ipairs(tbPotential) do
|
||
local itemCfg = ConfigTable.GetData("Item", nPotentialId)
|
||
if itemCfg ~= nil then
|
||
local nRarity = itemCfg.Rarity
|
||
if itemCfg.Stype == GameEnum.itemStype.SpecificPotential then
|
||
nRarity = 0
|
||
end
|
||
if curRarity > nRarity then
|
||
ret = {}
|
||
curRarity = nRarity
|
||
table.insert(ret, {nId = nPotentialId})
|
||
elseif nRarity == curRarity then
|
||
table.insert(ret, {nId = nPotentialId})
|
||
end
|
||
end
|
||
end
|
||
if #ret < 2 then
|
||
return ret
|
||
end
|
||
local ret1 = {}
|
||
local nCurCharId = 0
|
||
local nCurCount = -1
|
||
local GetCharacterPotentialCount = function(nCharId)
|
||
local ret = 0
|
||
if self._mapPotential[nCharId] ~= nil then
|
||
for _, nCount in pairs(self._mapPotential[nCharId]) do
|
||
ret = ret + nCount
|
||
end
|
||
end
|
||
return ret
|
||
end
|
||
for _, v in ipairs(ret) do
|
||
local nPotentialId = v.nId
|
||
local potentialCfg = ConfigTable.GetData("Potential", nPotentialId)
|
||
if potentialCfg ~= nil then
|
||
local nCharId = potentialCfg.CharId
|
||
local nCount = GetCharacterPotentialCount(nCharId)
|
||
if nCurCount < 0 then
|
||
nCurCharId = nCharId
|
||
nCurCount = nCount
|
||
table.insert(ret1, {nId = nPotentialId})
|
||
elseif nCharId ~= nCurCharId and nCount < nCurCount then
|
||
ret1 = {}
|
||
nCurCharId = nCharId
|
||
nCurCount = nCount
|
||
table.insert(ret1, {nId = nPotentialId})
|
||
else
|
||
table.insert(ret1, {nId = nPotentialId})
|
||
end
|
||
end
|
||
end
|
||
if #ret1 < 1 then
|
||
return ret
|
||
end
|
||
if #ret1 < 2 then
|
||
return ret1
|
||
end
|
||
local ret2 = {}
|
||
local nCurBuildCount = -1
|
||
local bHasBuild = false
|
||
local GetPotentialBuildCount = function(nPotnetialId)
|
||
local ret = 0
|
||
local retBuild = 0
|
||
local potentialCfg = ConfigTable.GetData("Potential", nPotnetialId)
|
||
if potentialCfg ~= nil then
|
||
retBuild = potentialCfg.Build
|
||
local nCharId = potentialCfg.CharId
|
||
for nId, nCount in pairs(self._mapPotential[nCharId]) do
|
||
local mapCfg = ConfigTable.GetData("Potential", nId)
|
||
local potentialItemCfg = ConfigTable.GetData_Item(nId)
|
||
if mapCfg ~= nil and potentialItemCfg ~= nil then
|
||
local param = 1
|
||
if potentialItemCfg.Stype == GameEnum.itemStype.SpecificPotential then
|
||
param = 99
|
||
end
|
||
if mapCfg.Build == potentialCfg.Build then
|
||
ret = ret + param
|
||
end
|
||
end
|
||
end
|
||
end
|
||
return ret, retBuild
|
||
end
|
||
for _, v in ipairs(ret1) do
|
||
local nPotentialId = v.nId
|
||
local nCount, nBuild = GetPotentialBuildCount(nPotentialId)
|
||
if nCurBuildCount < 0 and nBuild ~= 0 then
|
||
table.insert(ret2, {nId = nPotentialId})
|
||
nCurBuildCount = nCount
|
||
bHasBuild = nBuild ~= GameEnum.potentialBuild.PotentialBuildCommon
|
||
elseif bHasBuild then
|
||
if nBuild ~= GameEnum.potentialBuild.PotentialBuildCommon then
|
||
if nCount == nCurBuildCount then
|
||
table.insert(ret2, {nId = nPotentialId})
|
||
elseif nCount > nCurBuildCount then
|
||
ret2 = {}
|
||
table.insert(ret2, {nId = nPotentialId})
|
||
nCurBuildCount = nCount
|
||
bHasBuild = nBuild ~= GameEnum.potentialBuild.PotentialBuildCommon
|
||
end
|
||
end
|
||
elseif nBuild == GameEnum.potentialBuild.PotentialBuildCommon then
|
||
if nCount == nCurBuildCount then
|
||
table.insert(ret2, {nId = nPotentialId})
|
||
elseif nCount > nCurBuildCount then
|
||
ret2 = {}
|
||
table.insert(ret2, {nId = nPotentialId})
|
||
nCurBuildCount = nCount
|
||
end
|
||
else
|
||
ret2 = {}
|
||
table.insert(ret2, {nId = nPotentialId})
|
||
nCurBuildCount = nCount
|
||
bHasBuild = true
|
||
end
|
||
end
|
||
if #ret2 < 1 then
|
||
return ret1
|
||
end
|
||
if #ret2 < 2 then
|
||
return ret2
|
||
end
|
||
local ret3 = {}
|
||
local curLessPotential = -1
|
||
for _, v in ipairs(ret2) do
|
||
local nPotentialId = v.nId
|
||
local potentialCfg = ConfigTable.GetData("Potential", nPotentialId)
|
||
if potentialCfg ~= nil then
|
||
local nCharId = potentialCfg.CharId
|
||
local nCurCount = 0
|
||
if self._mapPotential[nCharId] ~= nil and self._mapPotential[nCharId][nPotentialId] ~= nil then
|
||
nCurCount = self._mapPotential[nCharId][nPotentialId]
|
||
end
|
||
if curLessPotential < 0 then
|
||
table.insert(ret3, {nId = nPotentialId})
|
||
curLessPotential = nCurCount
|
||
elseif nCurCount == curLessPotential then
|
||
table.insert(ret3, {nId = nPotentialId})
|
||
elseif nCurCount < curLessPotential then
|
||
ret3 = {}
|
||
table.insert(ret3, {nId = nPotentialId})
|
||
curLessPotential = nCurCount
|
||
end
|
||
end
|
||
end
|
||
if #ret3 < 1 then
|
||
return ret2
|
||
end
|
||
return ret3
|
||
end
|
||
function StarTowerSweepData:GetShopGoods()
|
||
local nType = self.nRoomType
|
||
local mapStarTower = ConfigTable.GetData("StarTower", self.nTowerId)
|
||
if not mapStarTower then
|
||
return
|
||
end
|
||
local nNpcId = mapStarTower.ShopNpc
|
||
if nType ~= GameEnum.starTowerRoomType.ShopRoom then
|
||
nNpcId = mapStarTower.StandShopNpc
|
||
end
|
||
if self.mapCases[self.EnumCase.Hawker] and self.mapNpc[nNpcId] then
|
||
return self.mapCases[self.EnumCase.Hawker].List
|
||
end
|
||
end
|
||
return StarTowerSweepData
|