Major Update - 2.0.0.143

EN: 2.0.0.143
CN: 2.0.0.142
JP: 2.0.0.145
KR: 2.0.0.150

lua/game/ui/startowerfastbattle/startowerautodecisionhudctrl.lua

@@ -0,0 +1,276 @@
+local StarTowerAutoDecisionHUDCtrl = class("StarTowerAutoDecisionHUDCtrl", BaseCtrl)
+local GamepadUIManager = require("GameCore.Module.GamepadUIManager")
+local Time = CS.UnityEngine.Time
+local TimerManager = require("GameCore.Timer.TimerManager")
+local StarTowerSettingGate = require("Game.Adventure.StarTower.StarTowerSettingGate")
+local StarTowerAutoDecision = require("Game.Adventure.StarTower.StarTowerAutoDecision")
+local AUTO_INPUT_LAYER = "StarTowerAutoDecisionHUDCtrl"
+local LOCKED_TIPS_INTERVAL = 0.8
+local AUTO_SWITCH_COOLDOWN = 0.25
+local mapPauseKeyboardInput = {
+	enter = true,
+	numpadEnter = true,
+	space = true
+}
+StarTowerAutoDecisionHUDCtrl._mapNodeConfig = {
+	rtAutoOpen = {
+		sCtrlName = "Game.UI.StarTowerFastBattle.StarTowerAutoDecisionPhoneCtrl"
+	},
+	animAutoOpen = {sNodeName = "rtAutoOpen", sComponentName = "Animator"},
+	rtAutoBattle = {
+		sCtrlName = "Game.UI.StarTowerFastBattle.StarTowerAutoDecisionPhoneCtrl"
+	},
+	animAutoBattle = {
+		sNodeName = "rtAutoBattle",
+		sComponentName = "Animator"
+	},
+	rtAutoBattleShortcut = {
+		sNodeName = "rtAutoBattle",
+		sComponentName = "NaviButton",
+		callback = "OnBtnClick_Stop"
+	},
+	goAutoInputBlock = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_InputBlock"
+	},
+	btnAutoOn = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_AutoOn"
+	},
+	btnStop = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_Stop"
+	},
+	txtAutoOn = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "AutoDecision_Enable"
+	},
+	btnOpenSetting = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_OpenSetting"
+	},
+	txtAutoSearch = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "AutoDecision_Ongoing"
+	}
+}
+StarTowerAutoDecisionHUDCtrl._mapEventConfig = {
+	StarTowerAutoDecisionStateChanged = "OnEvent_AutoDecisionStateChanged",
+	StarTowerAutoDecisionSettingStateChanged = "OnEvent_AutoDecisionSettingStateChanged",
+	OpenStarTowerDepot = "OnEvent_OpenStarTowerDepot",
+	CloseStarTowerDepot = "OnEvent_CloseStarTowerDepot",
+	LuaEventName_KeyboardButtonPress = "OnEvent_KeyboardButtonPress",
+	LuaEventName_MouseButtonPress = "OnEvent_MouseButtonPress",
+	LuaEventName_GamepadButtonPress = "OnEvent_GamepadButtonPress"
+}
+function StarTowerAutoDecisionHUDCtrl:Awake()
+	self._bInputLocked = false
+	self._bDepotOpen = false
+	self._nNextLockedTipsTime = 0
+	self._nNextSettingBusyTipsTime = 0
+end
+function StarTowerAutoDecisionHUDCtrl:OnEnable()
+	self._bSettingOpen = PanelManager.CheckPanelOpen(PanelId.StarTowerAutoDecisionSettingPanel)
+	self.canvas = self.gameObject.transform:GetComponent("Canvas")
+	NovaAPI.SetCanvasOverrideSorting(self.canvas, true)
+	NovaAPI.SetCanvasSortingName(self.canvas, AllEnum.SortingLayerName.UI_Top)
+	NovaAPI.SetCanvasSortingOrder(self.canvas, AllEnum.UI_SORTING_ORDER.StarTowerAutoDecisionHUD)
+	self:Refresh()
+end
+function StarTowerAutoDecisionHUDCtrl:OnDisable()
+	TimerManager.Remove(self._timerAutoOpenHide, false)
+	TimerManager.Remove(self._timerAutoBattleHide, false)
+	TimerManager.Remove(self._timerAutoSwitch, false)
+	self._timerAutoOpenHide = nil
+	self._timerAutoBattleHide = nil
+	self._timerAutoSwitch = nil
+	self._mapNode.rtAutoOpen.gameObject:SetActive(false)
+	self._mapNode.rtAutoBattle.gameObject:SetActive(false)
+	self:SetInputLocked(false)
+end
+function StarTowerAutoDecisionHUDCtrl:RefreshAutoNode(sNodeName, sAnimatorName, sAnimationPrefix, sTimerName, bVisible)
+	local objCtrl = self._mapNode[sNodeName]
+	local animator = self._mapNode[sAnimatorName]
+	if self._bSettingOpen then
+		TimerManager.Remove(self[sTimerName], false)
+		self[sTimerName] = nil
+		objCtrl.gameObject:SetActive(false)
+		return
+	end
+	if bVisible then
+		local bPlayIn = self[sTimerName] ~= nil or not objCtrl.gameObject.activeSelf
+		TimerManager.Remove(self[sTimerName], false)
+		self[sTimerName] = nil
+		objCtrl.gameObject:SetActive(true)
+		if bPlayIn then
+			animator:Play(sAnimationPrefix .. "_in", 0, 0)
+		end
+		objCtrl:Refresh()
+	elseif objCtrl.gameObject.activeSelf and self[sTimerName] == nil then
+		animator:Play(sAnimationPrefix .. "_out", 0, 0)
+		self[sTimerName] = self:AddTimer(1, 0.2, function()
+			self[sTimerName] = nil
+			objCtrl.gameObject:SetActive(false)
+		end, true, true, true)
+		if self[sTimerName] == nil then
+			objCtrl.gameObject:SetActive(false)
+		end
+	end
+end
+function StarTowerAutoDecisionHUDCtrl:CanUseAutoOpenButtons(bSetting)
+	local objLevelData = self._panel.LevelData
+	return self._timerAutoSwitch == nil and not self._bDepotOpen and not self._bSettingOpen and not self._bInputLocked and objLevelData ~= nil and objLevelData.bEnd ~= true and not objLevelData:IsAutoDecisionEnabled() and (bSetting or not objLevelData:IsAutoDecisionBusy())
+end
+function StarTowerAutoDecisionHUDCtrl:RefreshButtonInteractable()
+	local bInteractable = self._timerAutoSwitch == nil and not self._bDepotOpen
+	local bAutoOpenInteractable = self:CanUseAutoOpenButtons()
+	self._mapNode.btnAutoOn.interactable = bAutoOpenInteractable
+	self._mapNode.btnOpenSetting.interactable = self:CanUseAutoOpenButtons(true)
+	self._mapNode.btnStop.interactable = bInteractable and self._bInputLocked
+	self._mapNode.rtAutoBattleShortcut.interactable = bInteractable and self._bInputLocked
+end
+function StarTowerAutoDecisionHUDCtrl:StartSwitchCooldown()
+	self._timerAutoSwitch = self:AddTimer(1, AUTO_SWITCH_COOLDOWN, function()
+		self._timerAutoSwitch = nil
+		self:RefreshButtonInteractable()
+	end, true, true, true)
+	self:RefreshButtonInteractable()
+end
+function StarTowerAutoDecisionHUDCtrl:Refresh(bEnabled)
+	if type(bEnabled) ~= "boolean" then
+		bEnabled = self._panel.LevelData ~= nil and self._panel.LevelData:IsAutoDecisionEnabled()
+	end
+	local bOpen = not self._bDepotOpen and not bEnabled
+	local bBattle = not self._bDepotOpen and bEnabled
+	if not bEnabled then
+		self:SetInputLocked(false)
+	end
+	self:RefreshAutoNode("rtAutoOpen", "animAutoOpen", "StarTowerAutoOpen", "_timerAutoOpenHide", bOpen)
+	self:RefreshAutoNode("rtAutoBattle", "animAutoBattle", "StarTowerAutoBattle", "_timerAutoBattleHide", bBattle)
+	if bEnabled then
+		self:SetInputLocked(true)
+	end
+	self:RefreshButtonInteractable()
+end
+function StarTowerAutoDecisionHUDCtrl:SetInputLocked(bLocked)
+	bLocked = bLocked == true
+	self._mapNode.goAutoInputBlock.gameObject:SetActive(bLocked)
+	if self._bInputLocked == bLocked then
+		return
+	end
+	self._bInputLocked = bLocked
+	if bLocked then
+		GamepadUIManager.EnableGamepadUI(AUTO_INPUT_LAYER, {
+			{
+				mapNode = self._mapNode.rtAutoBattleShortcut,
+				sComponentName = "NaviButton",
+				sAction = "buttonSouth"
+			}
+		}, self._mapNode.rtAutoBattleShortcut.gameObject, false, false, AllEnum.UI_SORTING_ORDER.StarTowerAutoDecisionHUD)
+	else
+		GamepadUIManager.DisableGamepadUI(AUTO_INPUT_LAYER)
+	end
+end
+function StarTowerAutoDecisionHUDCtrl:ShowInputLockedTips()
+	if not self._bInputLocked then
+		return
+	end
+	local nNow = Time.realtimeSinceStartup
+	if nNow < self._nNextLockedTipsTime then
+		return
+	end
+	self._nNextLockedTipsTime = nNow + LOCKED_TIPS_INTERVAL
+	EventManager.Hit(EventId.OpenMessageBox, ConfigTable.GetUIText("AutoDecision_InputLocked"))
+end
+function StarTowerAutoDecisionHUDCtrl:OnEvent_AutoDecisionStateChanged(mapState)
+	if type(mapState) ~= "table" then
+		self:Refresh()
+		return
+	end
+	local bEnabled = mapState.bEnabled == true and mapState.bPaused ~= true
+	self:Refresh(bEnabled)
+	if mapState.nFailReason == StarTowerAutoDecision.FailReason.TokenNotEnough then
+		EventManager.Hit(EventId.OpenMessageBox, ConfigTable.GetUIText("AutoDecision_InsufficientToken"))
+	end
+end
+function StarTowerAutoDecisionHUDCtrl:OnEvent_OpenStarTowerDepot()
+	self._bDepotOpen = true
+	self:Refresh()
+end
+function StarTowerAutoDecisionHUDCtrl:OnEvent_CloseStarTowerDepot()
+	self._bDepotOpen = false
+	self:Refresh()
+end
+function StarTowerAutoDecisionHUDCtrl:OnEvent_AutoDecisionSettingStateChanged(bOpen)
+	self._bSettingOpen = bOpen == true
+	self:Refresh()
+end
+function StarTowerAutoDecisionHUDCtrl:OnBtnClick_AutoOn()
+	if not (self._mapNode.btnAutoOn.interactable and self:CanUseAutoOpenButtons()) or PanelManager.CheckPanelOpen(PanelId.StarTowerAutoDecisionSettingPanel) then
+		return
+	end
+	self:StartSwitchCooldown()
+	if PlayerData.StarTowerAutoPlan:GetTokenCount() <= 0 then
+		EventManager.Hit(EventId.OpenMessageBox, ConfigTable.GetUIText("AutoDecision_InsufficientToken"))
+		return
+	end
+	local bSuccess = self._panel.LevelData:SetAutoDecisionEnabled(true)
+	if not bSuccess then
+		TimerManager.Remove(self._timerAutoSwitch, false)
+		self._timerAutoSwitch = nil
+		self:RefreshButtonInteractable()
+		self:OnBtnClick_OpenSetting()
+	elseif self._panel.LevelData:IsAutoDecisionEnabled() then
+		local nCurPlanId = PlayerData.StarTowerAutoPlan:GetSelectedPlanId()
+		local sPlanName = PlayerData.StarTowerAutoPlan:GetPlanById(nCurPlanId).sName
+		local sTip = orderedFormat(ConfigTable.GetUIText("AutoDecision_PlanActivatedTip"), sPlanName)
+		EventManager.Hit(EventId.OpenMessageBox, sTip)
+	end
+end
+function StarTowerAutoDecisionHUDCtrl:OnBtnClick_Stop()
+	if not self._mapNode.btnStop.interactable then
+		return
+	end
+	self:StartSwitchCooldown()
+	self:SetInputLocked(false)
+	if self._panel.LevelData ~= nil then
+		self._panel.LevelData:SetAutoDecisionEnabled(false, true)
+	end
+end
+function StarTowerAutoDecisionHUDCtrl:OnBtnClick_InputBlock()
+	self:ShowInputLockedTips()
+end
+function StarTowerAutoDecisionHUDCtrl:OnBtnClick_OpenSetting()
+	if not (self._mapNode.btnOpenSetting.interactable and self:CanUseAutoOpenButtons(true)) or PanelManager.CheckPanelOpen(PanelId.StarTowerAutoDecisionSettingPanel) then
+		return
+	end
+	if not StarTowerSettingGate.CanOpen(self._panel.LevelData) or PanelManager.CheckPanelOpen(PanelId.StarTowerFastBattleLog) or PanelManager.CheckPanelOpen(PanelId.StarTowerShop) or PanelManager.CheckPanelOpen(PanelId.NoteSkillInfo) then
+		local nNow = Time.realtimeSinceStartup
+		if nNow >= self._nNextSettingBusyTipsTime then
+			self._nNextSettingBusyTipsTime = nNow + LOCKED_TIPS_INTERVAL
+			local sTips = ConfigTable.GetUIText("AutoDecision_SettingBusy")
+			EventManager.Hit(EventId.OpenMessageBox, sTips)
+		end
+		return
+	end
+	EventManager.Hit(EventId.OpenPanel, PanelId.StarTowerAutoDecisionSettingPanel)
+end
+function StarTowerAutoDecisionHUDCtrl:OnEvent_KeyboardButtonPress(mapInput)
+	if not self._bInputLocked or mapPauseKeyboardInput[mapInput.name] then
+		return
+	end
+	self:ShowInputLockedTips()
+end
+function StarTowerAutoDecisionHUDCtrl:OnEvent_MouseButtonPress(mapInput)
+	if not self._bInputLocked or mapInput.name == "leftButton" or mapInput.name == "rightButton" then
+		return
+	end
+	self:ShowInputLockedTips()
+end
+function StarTowerAutoDecisionHUDCtrl:OnEvent_GamepadButtonPress(mapInput)
+	if not self._bInputLocked or mapInput.name == "buttonSouth" then
+		return
+	end
+	self:ShowInputLockedTips()
+end
+return StarTowerAutoDecisionHUDCtrl

lua/game/ui/startowerfastbattle/startowerautodecisionhudpanel.lua

@@ -0,0 +1,20 @@
+local StarTowerAutoDecisionHUDPanel = class("StarTowerAutoDecisionHUDPanel", BasePanel)
+StarTowerAutoDecisionHUDPanel._bIsMainPanel = false
+StarTowerAutoDecisionHUDPanel._sSortingLayerName = AllEnum.SortingLayerName.UI_Top
+StarTowerAutoDecisionHUDPanel._tbDefine = {
+	{
+		sPrefabPath = "StarTowerFastBattle/StarTowerAutoBattlePopup.prefab",
+		sCtrlName = "Game.UI.StarTowerFastBattle.StarTowerAutoDecisionHUDCtrl"
+	}
+}
+function StarTowerAutoDecisionHUDPanel:Awake()
+	local tbParam = self:GetPanelParam()
+	self.LevelData = tbParam and tbParam[1] or nil
+end
+function StarTowerAutoDecisionHUDPanel:OnEnable()
+end
+function StarTowerAutoDecisionHUDPanel:OnDisable()
+end
+function StarTowerAutoDecisionHUDPanel:OnDestroy()
+end
+return StarTowerAutoDecisionHUDPanel

lua/game/ui/startowerfastbattle/startowerautodecisionphonectrl.lua

@@ -0,0 +1,48 @@
+local StarTowerAutoDecisionPhoneCtrl = class("StarTowerAutoDecisionPhoneCtrl", BaseCtrl)
+StarTowerAutoDecisionPhoneCtrl._mapNodeConfig = {
+	txtVitaToken = {sComponentName = "TMP_Text"},
+	txtVitaName = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "AutoDecision_VitaName"
+	},
+	imgBattleCD = {sComponentName = "Image"}
+}
+StarTowerAutoDecisionPhoneCtrl._mapEventConfig = {
+	[EventId.CoinResChange] = "OnEvent_CoinResChange"
+}
+local tbColors = {
+	[1] = "#ea5964",
+	[2] = "#ffde6a",
+	[3] = "#bde34f"
+}
+function StarTowerAutoDecisionPhoneCtrl:Refresh()
+	self.nTokenCount = PlayerData.StarTowerAutoPlan:GetTokenCount()
+	self.nMaxTokenCount = ConfigTable.GetConfigNumber("TowerVitaEnergyMax") or 0
+	local nPercent = self.nMaxTokenCount > 0 and math.floor(self.nTokenCount * 100 / self.nMaxTokenCount) or 0
+	local nRatio = nPercent / 100
+	NovaAPI.SetImageFillAmount(self._mapNode.imgBattleCD, nRatio)
+	local color
+	if 0 <= nRatio and nRatio < 0.1 then
+		color = tbColors[1]
+	elseif 0.1 <= nRatio and nRatio < 0.3 then
+		color = tbColors[2]
+	elseif 0.3 <= nRatio then
+		color = tbColors[3]
+	end
+	if nRatio < 0.01 and 0 < nRatio then
+		nRatio = 0.01
+	end
+	NovaAPI.SetTMPText(self._mapNode.txtVitaToken, nPercent .. "%")
+	local _, myColor = ColorUtility.TryParseHtmlString(color)
+	NovaAPI.SetImageColor(self._mapNode.imgBattleCD, myColor)
+	NovaAPI.SetTMPColor(self._mapNode.txtVitaToken, myColor)
+end
+function StarTowerAutoDecisionPhoneCtrl:OnEnable()
+	self:Refresh()
+end
+function StarTowerAutoDecisionPhoneCtrl:OnEvent_CoinResChange(nItemId)
+	if nItemId == AllEnum.CoinItemId.AutoDecisionToken then
+		self:Refresh()
+	end
+end
+return StarTowerAutoDecisionPhoneCtrl

lua/game/ui/startowerfastbattle/startowerautodecisionrenamectrl.lua

@@ -0,0 +1,133 @@
+local StarTowerAutoDecisionRenameCtrl = class("StarTowerAutoDecisionRenameCtrl", BaseCtrl)
+StarTowerAutoDecisionRenameCtrl._mapNodeConfig = {
+	blur = {sNodeName = "blurRename"},
+	aniBlur = {sNodeName = "blurRename", sComponentName = "Animator"},
+	aniWindow = {
+		sNodeName = "---Rename---",
+		sComponentName = "Animator"
+	},
+	goWindow = {
+		sNodeName = "---Rename---"
+	},
+	txtWindowTitle = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Friend_Rename"
+	},
+	txtOldName = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Build_OldName"
+	},
+	txtNameDesc = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Friend_NameDesc"
+	},
+	txtCurName = {sComponentName = "TMP_Text"},
+	inputRename = {
+		sComponentName = "TMP_InputField"
+	},
+	btnBlur = {
+		sNodeName = "snapshot",
+		sComponentName = "Button",
+		callback = "OnBtnClick_Cancel"
+	},
+	btnClose = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_Cancel"
+	},
+	btnCancel = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_Cancel"
+	},
+	btnConfirm1 = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_Confirm"
+	},
+	txtBtnConfirm = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Friend_Btn_Confirm"
+	},
+	txtBtnCancel = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Friend_Btn_Cancel"
+	}
+}
+StarTowerAutoDecisionRenameCtrl._mapEventConfig = {}
+function StarTowerAutoDecisionRenameCtrl:Open(mapPlan, callback)
+	self.gameObject:SetActive(true)
+	self.mapPlan = mapPlan
+	self.sCurName = mapPlan.sName
+	self.callback = callback
+	self:Refresh()
+	self:PlayInAni()
+end
+function StarTowerAutoDecisionRenameCtrl:Refresh()
+	local bInit = NovaAPI.IsDirtyWordsInit()
+	if not bInit then
+		NovaAPI.InitDirtyWords()
+	end
+	NovaAPI.SetTMPInputFieldText(self._mapNode.inputRename, "")
+	if self.sCurName ~= nil and self.sCurName ~= "" then
+		NovaAPI.SetTMPText(self._mapNode.txtCurName, self.sCurName)
+	elseif self.mapPlan.sName == "" or self.mapPlan.sName == nil then
+		NovaAPI.SetTMPText(self._mapNode.txtCurName, ConfigTable.GetUIText("RoguelikeBuild_EmptyBuildName"))
+	else
+		NovaAPI.SetTMPText(self._mapNode.txtCurName, self.mapPlan.sName)
+	end
+end
+function StarTowerAutoDecisionRenameCtrl:PlayInAni()
+	self._mapNode.goWindow:SetActive(true)
+	self._mapNode.blur:SetActive(true)
+	self._mapNode.aniWindow:Play("t_window_04_t_in")
+	EventManager.Hit(EventId.TemporaryBlockInput, 0.3)
+end
+function StarTowerAutoDecisionRenameCtrl:PlayOutAni()
+	self._mapNode.aniWindow:Play("t_window_04_t_out")
+	self._mapNode.aniBlur:SetTrigger("tOut")
+	EventManager.Hit(EventId.TemporaryBlockInput, 0.2)
+	self:AddTimer(1, 0.2, "Close", true, true, true)
+end
+function StarTowerAutoDecisionRenameCtrl:Close()
+	self.gameObject:SetActive(false)
+end
+function StarTowerAutoDecisionRenameCtrl:Awake()
+end
+function StarTowerAutoDecisionRenameCtrl:OnEnable()
+end
+function StarTowerAutoDecisionRenameCtrl:OnDisable()
+end
+function StarTowerAutoDecisionRenameCtrl:OnDestroy()
+end
+function StarTowerAutoDecisionRenameCtrl:OnBtnClick_Cancel(btn)
+	self:PlayOutAni()
+end
+function StarTowerAutoDecisionRenameCtrl:OnBtnClick_Confirm(btn)
+	local sNewName = NovaAPI.GetTMPInputFieldText(self._mapNode.inputRename)
+	if sNewName == "" then
+		EventManager.Hit(EventId.OpenMessageBox, ConfigTable.GetUIText("BUILD_05"))
+		return
+	end
+	local bInit = NovaAPI.IsDirtyWordsInit()
+	if not bInit then
+		NovaAPI.InitDirtyWords()
+	end
+	if NovaAPI.IsDirtyString(sNewName) then
+		EventManager.Hit(EventId.OpenMessageBox, ConfigTable.GetUIText("PLAYER_01"))
+		return
+	end
+	if self.bSkip then
+		self:PlayOutAni()
+		if self.callback then
+			self.callback(sNewName)
+		end
+	else
+		local nPlanId = self.mapPlan.nPlanId or self.mapPlan.Id
+		PlayerData.StarTowerAutoPlan:SendRenamePlan(nPlanId, sNewName, function()
+			self.mapPlan.sName = sNewName
+			if self.callback then
+				self.callback(sNewName)
+			end
+			self:PlayOutAni()
+		end)
+	end
+end
+return StarTowerAutoDecisionRenameCtrl

lua/game/ui/startowerfastbattle/startowerautodecisionsettingctrl.lua

@@ -0,0 +1,492 @@
+local StarTowerAutoDecisionSettingCtrl = class("StarTowerAutoDecisionSettingCtrl", BaseCtrl)
+local GamepadUIManager = require("GameCore.Module.GamepadUIManager")
+local StarTowerSettingGate = require("Game.Adventure.StarTower.StarTowerSettingGate")
+local ClientManager = CS.ClientManager
+StarTowerAutoDecisionSettingCtrl._mapNodeConfig = {
+	imgBlurredBg = {},
+	goContentAnim = {},
+	animRoot = {
+		sNodeName = "goContentAnim",
+		sComponentName = "Animator"
+	},
+	presetListLSV = {
+		sComponentName = "LoopScrollView"
+	},
+	txtPresetTitle = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "AutoDecision_PresetSelect"
+	},
+	btnClosePanel = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_ClosePanel"
+	},
+	txtTime = {sComponentName = "TMP_Text"},
+	txtBtnReset = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "AutoDecision_PresetReset"
+	},
+	btnResetPlan = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_Reset"
+	},
+	btnRename = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_Rename"
+	},
+	txtPresetName = {sComponentName = "TMP_Text"},
+	goRename = {
+		sCtrlName = "Game.UI.StarTowerFastBattle.StarTowerAutoDecisionRenameCtrl"
+	},
+	PresetFirst = {
+		sCtrlName = "Game.UI.Settings.OptionSwitchCtrl"
+	},
+	PresetOnly = {
+		sCtrlName = "Game.UI.Settings.OptionSwitchCtrl"
+	},
+	PotentialSort = {
+		sCtrlName = "Game.UI.Settings.OptionMultiSelect"
+	},
+	txtTitlePotential = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "AutoDecision_Potential"
+	},
+	PotentialReroll = {
+		sCtrlName = "Game.UI.Settings.OptionSwitchCtrl"
+	},
+	PotentialRerollCoin = {
+		sCtrlName = "Game.UI.TemplateEx.TemplateSimpleQuantitySelectorCtrl"
+	},
+	txtPotentialRerollCoin = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "AutoDecision_PotentialCoinRerollNum"
+	},
+	PriorityConsumption = {
+		sCtrlName = "Game.UI.Settings.OptionChooseCtrl"
+	},
+	ShopSelect = {
+		sCtrlName = "Game.UI.Settings.OptionMultiSelect"
+	},
+	goShopDropdown = {
+		sCtrlName = "Game.UI.TemplateEx.TemplateDropdownCtrl"
+	},
+	txtTitleShop = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "AutoDecision_Shop"
+	},
+	txtShopUpgrade = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "AutoDecision_ShopUpgradePrice"
+	},
+	ShopCoin = {
+		sCtrlName = "Game.UI.TemplateEx.TemplateSimpleQuantitySelectorCtrl"
+	},
+	txtShopCoinReroll = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "AutoDecision_PotentialCoinRerollNum"
+	},
+	ShopRefresh = {
+		sCtrlName = "Game.UI.Settings.OptionSwitchCtrl"
+	},
+	LastStageRefresh = {
+		sCtrlName = "Game.UI.Settings.OptionSwitchCtrl"
+	},
+	LastStageAllin = {
+		sCtrlName = "Game.UI.Settings.OptionSwitchCtrl"
+	},
+	txtTitleEvent = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "AutoDecision_Event"
+	},
+	TendencySelect = {
+		sCtrlName = "Game.UI.Settings.OptionChooseCtrl"
+	},
+	EventSelect = {
+		sCtrlName = "Game.UI.Settings.OptionMultiSelect"
+	},
+	txtTokenBar = {sComponentName = "TMP_Text"},
+	rtTokenBarFill = {
+		sComponentName = "RectTransform"
+	},
+	btnAddToken = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_AddToken"
+	}
+}
+StarTowerAutoDecisionSettingCtrl._mapEventConfig = {
+	CloseAutoDecisionSetting = "OnEvent_CloseAutoDecisionSetting",
+	SelectTemplateDD = "OnEvent_ShopDropdown",
+	RefreshTokenItemList = "RefreshTokenValue"
+}
+local _GetOptionTextList = function(mapConfig)
+	local tbOptionTextList = {}
+	if mapConfig ~= nil then
+		local sKey = "OptionText"
+		for i = 1, 10 do
+			local sThisKey = sKey .. i
+			local sValue = mapConfig[sThisKey]
+			if sValue ~= nil and sValue ~= "" then
+				table.insert(tbOptionTextList, sValue)
+			else
+				break
+			end
+		end
+	end
+	return tbOptionTextList
+end
+local _IsArrayEqual = function(tbLeft, tbRight)
+	if type(tbLeft) ~= "table" or type(tbRight) ~= "table" then
+		return tbLeft == tbRight
+	end
+	if #tbLeft ~= #tbRight then
+		return false
+	end
+	for i = 1, #tbLeft do
+		if tbLeft[i] ~= tbRight[i] then
+			return false
+		end
+	end
+	return true
+end
+local _GetOptionListValue = function(mapOption)
+	if type(mapOption) ~= "table" or type(mapOption.List) ~= "table" then
+		return nil
+	end
+	return mapOption.List.Values or mapOption.List.List or mapOption.List.Value
+end
+local _IsServerOptionEqual = function(mapLeft, mapRight)
+	if type(mapLeft) ~= "table" or type(mapRight) ~= "table" then
+		return mapLeft == mapRight
+	end
+	if mapLeft.Id ~= mapRight.Id then
+		return false
+	end
+	if mapLeft.Boolean ~= mapRight.Boolean or mapLeft.Integer ~= mapRight.Integer then
+		return false
+	end
+	return _IsArrayEqual(_GetOptionListValue(mapLeft), _GetOptionListValue(mapRight))
+end
+local _IsServerProjectEqual = function(mapLeft, mapRight)
+	if type(mapLeft) ~= "table" or type(mapRight) ~= "table" then
+		return mapLeft == mapRight
+	end
+	if mapLeft.Id ~= mapRight.Id then
+		return false
+	end
+	if mapLeft.Name ~= mapRight.Name then
+		return false
+	end
+	local tbLeftOptions = mapLeft.Options or {}
+	local tbRightOptions = mapRight.Options or {}
+	if #tbLeftOptions ~= #tbRightOptions then
+		return false
+	end
+	for i = 1, #tbLeftOptions do
+		if not _IsServerOptionEqual(tbLeftOptions[i], tbRightOptions[i]) then
+			return false
+		end
+	end
+	return true
+end
+function StarTowerAutoDecisionSettingCtrl:CacheOriginalServerProject()
+	self.mapOriginalServerProjectByPlanId = {}
+	self.mapOriginalDirtyByPlanId = {}
+	for _, mapPlan in pairs(self.tbPresetList or {}) do
+		self.mapOriginalServerProjectByPlanId[mapPlan.nPlanId] = PlayerData.StarTowerAutoPlan:BuildServerProject(mapPlan.nPlanId)
+		self.mapOriginalDirtyByPlanId[mapPlan.nPlanId] = PlayerData.StarTowerAutoPlan:IsDirty(mapPlan.nPlanId)
+	end
+end
+function StarTowerAutoDecisionSettingCtrl:RefreshPresetList()
+	if self.nCurSelectIndex == nil or self.nCurSelectIndex <= 0 then
+		self.nCurSelectIndex = PlayerData.StarTowerAutoPlan:GetSelectedPlanId()
+	end
+	self.tbPresetList = PlayerData.StarTowerAutoPlan:GetPlanList(true)
+	self.tbGoGrid = {}
+	self._mapNode.presetListLSV:Init(#self.tbPresetList, self, self.OnGridRefresh, self.OnGridClick)
+end
+function StarTowerAutoDecisionSettingCtrl:OnGridRefresh(go, nGridIndex)
+	local nIndex = nGridIndex + 1
+	if self.tbGoGrid[nIndex] == nil then
+		self.tbGoGrid[nIndex] = go
+	end
+	local imgSelectBg = go.transform:Find("btnGrid/AnimRoot/phoneItem/imgSelectBg")
+	imgSelectBg.gameObject:SetActive(nIndex == self.nCurSelectIndex)
+	local imgChoose = go.transform:Find("btnGrid/AnimRoot/phoneItem/imgChoose")
+	imgChoose.gameObject:SetActive(nIndex == self.nCurSelectIndex)
+	local txtName = go.transform:Find("btnGrid/AnimRoot/phoneItem/goNormal/txtName"):GetComponent("TMP_Text")
+	NovaAPI.SetTMPText(txtName, self.tbPresetList[nIndex].sName)
+	local txtName1 = go.transform:Find("btnGrid/AnimRoot/phoneItem/imgSelectBg/txtName1"):GetComponent("TMP_Text")
+	NovaAPI.SetTMPText(txtName1, self.tbPresetList[nIndex].sName)
+end
+function StarTowerAutoDecisionSettingCtrl:OnGridClick(go, nGridIndex)
+	local nIndex = nGridIndex + 1
+	self.nCurSelectIndex = nIndex
+	for k, v in pairs(self.tbGoGrid) do
+		local imgSelectBg = v.transform:Find("btnGrid/AnimRoot/phoneItem/imgSelectBg")
+		imgSelectBg.gameObject:SetActive(k == self.nCurSelectIndex)
+		local imgChoose = v.transform:Find("btnGrid/AnimRoot/phoneItem/imgChoose")
+		imgChoose.gameObject:SetActive(k == self.nCurSelectIndex)
+	end
+	self:RefreshPresetDetail()
+	local sCurPlanName = self.tbPresetList[nIndex].sName
+	local sTip = orderedFormat(ConfigTable.GetUIText("AutoDecision_SelectPlanTip"), sCurPlanName)
+	EventManager.Hit(EventId.OpenMessageBox, sTip)
+	EventManager.Hit(EventId.TemporaryBlockInput, 0.2)
+end
+function StarTowerAutoDecisionSettingCtrl:RefreshPresetBase()
+	self._mapNode.PresetFirst:SetText(ConfigTable.GetUIText("AutoDecision_PresetFirst"))
+	local func_Handler = ui_handler(self, self.OnBtnClick_PresetSwitch)
+	self._mapNode.PresetFirst:Init(func_Handler, true)
+	self._mapNode.PresetFirst:SetEnable(true)
+	self._mapNode.PresetOnly:SetText(ConfigTable.GetUIText("AutoDecision_PresetOnly"))
+	func_Handler = ui_handler(self, self.OnBtnClick_PresetOnlySwitch)
+	local sPresetOnlyLockTxt = orderedFormat(ConfigTable.GetUIText("AutoDecision_SettingLock"), ConfigTable.GetUIText("AutoDecision_PresetFirst"))
+	self._mapNode.PresetOnly:Init(func_Handler, true, sPresetOnlyLockTxt)
+	local mapConfigPotentialSort = ConfigTable.GetData("TowerVitaOption", AllEnum.StarTowerAutoDecisionSettings.PotentialSort)
+	local tbPotentialSortOption = _GetOptionTextList(mapConfigPotentialSort)
+	func_Handler = ui_handler(self, self.OnBtnClick_PotentialSort)
+	self._mapNode.PotentialSort:Init(tbPotentialSortOption, ConfigTable.GetUIText("AutoDecision_PotentialSort"), func_Handler)
+	self._mapNode.PotentialReroll:SetText(ConfigTable.GetUIText("AutoDecision_PotentialNoMatchReroll"))
+	func_Handler = ui_handler(self, self.OnBtnClick_PotentialRerollSwitch)
+	self._mapNode.PotentialReroll:Init(func_Handler, true)
+	func_Handler = ui_handler(self, self.OnBtnClick_PotentialRerollCoin)
+	local sGrayText = ConfigTable.GetUIText("AutoDecision_PotentialRefreshGray")
+	self._mapNode.PotentialRerollCoin:Init(1000, 100, func_Handler, sGrayText)
+	local mapConfigShopSort = ConfigTable.GetData("TowerVitaOption", AllEnum.StarTowerAutoDecisionSettings.ShopSort)
+	local tbShopSortOption = _GetOptionTextList(mapConfigShopSort)
+	func_Handler = ui_handler(self, self.OnBtnClick_ShopSort)
+	self._mapNode.ShopSelect:Init(tbShopSortOption, ConfigTable.GetUIText("AutoDecision_ShopSort"), func_Handler)
+	self._mapNode.ShopRefresh:SetText(ConfigTable.GetUIText("AutoDecision_ShopCoinReroll"))
+	func_Handler = ui_handler(self, self.OnBtnClick_ShopRefreshSwitch)
+	self._mapNode.ShopRefresh:Init(func_Handler, true)
+	func_Handler = ui_handler(self, self.OnBtnClick_ShopCoin)
+	local sShopGrayText = ConfigTable.GetUIText("AutoDecision_ShopRefreshGray")
+	self._mapNode.ShopCoin:Init(1000, 100, func_Handler, sShopGrayText)
+	self._mapNode.LastStageRefresh:SetText(ConfigTable.GetUIText("AutoDecision_ShopFinalReroll"))
+	func_Handler = ui_handler(self, self.OnBtnClick_ShopFinalRerollSwitch)
+	self._mapNode.LastStageRefresh:Init(func_Handler, true)
+	self._mapNode.LastStageAllin:SetText(ConfigTable.GetUIText("AutoDecision_ShopFinalAllIn"))
+	func_Handler = ui_handler(self, self.OnBtnClick_ShopFinalAllInSwitch)
+	self._mapNode.LastStageAllin:Init(func_Handler, true)
+	local mapConfigEventSort = ConfigTable.GetData("TowerVitaOption", AllEnum.StarTowerAutoDecisionSettings.EventSort)
+	local tbEventSortOption = _GetOptionTextList(mapConfigEventSort)
+	func_Handler = ui_handler(self, self.OnBtnClick_EventSort)
+	self._mapNode.EventSelect:Init(tbEventSortOption, ConfigTable.GetUIText("AutoDecision_EventSort"), func_Handler)
+end
+function StarTowerAutoDecisionSettingCtrl:RefreshPresetDetail()
+	self.mapCurPreset = self.tbPresetList[self.nCurSelectIndex]
+	NovaAPI.SetTMPText(self._mapNode.txtPresetName, self.mapCurPreset.sName)
+	self._mapNode.PresetFirst:SetOn(self.mapCurPreset.mapPotential.bPresetFirst)
+	if not self.mapCurPreset.mapPotential.bPresetFirst then
+		self.mapCurPreset.mapPotential.bPresetOnly = false
+	end
+	self._mapNode.PresetOnly:SetOn(self.mapCurPreset.mapPotential.bPresetOnly)
+	self._mapNode.PresetOnly:SetEnable(self.mapCurPreset.mapPotential.bPresetFirst)
+	self._mapNode.PotentialSort:SetSelect(self.mapCurPreset.mapPotential.tbPotentialSort)
+	self._mapNode.PotentialReroll:SetOn(self.mapCurPreset.mapPotential.bPotentialReroll)
+	self._mapNode.PotentialRerollCoin:SetGray(not self.mapCurPreset.mapPotential.bPotentialReroll)
+	self._mapNode.PotentialRerollCoin:SetValue(self.mapCurPreset.mapPotential.nPotentialRerollCoinNum)
+	local mapConfigShopChoose = ConfigTable.GetData("TowerVitaOption", AllEnum.StarTowerAutoDecisionSettings.ShopFirstChoose)
+	local tbShopChooseOption = _GetOptionTextList(mapConfigShopChoose)
+	self.nShopChooseOptionCount = #tbShopChooseOption
+	func_Handler = ui_handler(self, self.OnBtnClick_ShopChoose)
+	self._mapNode.PriorityConsumption:Init(func_Handler, self.mapCurPreset.mapShop.nShopFirst, self.nShopChooseOptionCount)
+	self._mapNode.PriorityConsumption:SetText(tbShopChooseOption[1], tbShopChooseOption[2], tbShopChooseOption[3], ConfigTable.GetUIText("AutoDecision_ShopFirst"))
+	local mapConfigShopDropdown = ConfigTable.GetData("TowerVitaOption", AllEnum.StarTowerAutoDecisionSettings.ShopUpgradeDropdown)
+	self.tbDropdownOption = _GetOptionTextList(mapConfigShopDropdown)
+	local nRecordValue = self.mapCurPreset.mapShop.nShopUpgradePrice
+	local nDropdownValue = 0
+	for nIndex, sValue in ipairs(self.tbDropdownOption) do
+		if tonumber(sValue) == nRecordValue then
+			nDropdownValue = nIndex - 1
+			break
+		end
+	end
+	self._mapNode.goShopDropdown:SetList(self.tbDropdownOption, nDropdownValue, true)
+	self._mapNode.ShopSelect:SetSelect(self.mapCurPreset.mapShop.tbShopSort)
+	self._mapNode.ShopRefresh:SetOn(self.mapCurPreset.mapShop.bShopCoinReroll)
+	self._mapNode.ShopCoin:SetGray(not self.mapCurPreset.mapShop.bShopCoinReroll)
+	self._mapNode.ShopCoin:SetValue(self.mapCurPreset.mapShop.nShopCoinNum)
+	self._mapNode.LastStageRefresh:SetOn(self.mapCurPreset.mapShop.bShopFinalReroll)
+	self._mapNode.LastStageAllin:SetOn(self.mapCurPreset.mapShop.bShopFinalAllIn)
+	local mapConfigTendency = ConfigTable.GetData("TowerVitaOption", AllEnum.StarTowerAutoDecisionSettings.EventTendency)
+	local tbTendencyOption = _GetOptionTextList(mapConfigTendency)
+	self.nTendencyCount = #tbTendencyOption
+	func_Handler = ui_handler(self, self.OnBtnClick_TendencySelect)
+	self._mapNode.TendencySelect:Init(func_Handler, self.mapCurPreset.mapEvent.nEventTendency, self.nTendencyCount)
+	self._mapNode.TendencySelect:SetText(tbTendencyOption[1], tbTendencyOption[2], tbTendencyOption[3], ConfigTable.GetUIText("AutoDecision_EventTendency"))
+	self._mapNode.EventSelect:SetSelect(self.mapCurPreset.mapEvent.tbEventSort)
+end
+local nMaxBarLength = 344
+function StarTowerAutoDecisionSettingCtrl:RefreshTokenValue()
+	local nTokenCount = PlayerData.StarTowerAutoPlan:GetTokenCount()
+	local nMaxTokenCount = PlayerData.StarTowerAutoPlan:GetMaxTokenCount()
+	local nRatio = nTokenCount / nMaxTokenCount
+	if nRatio < 0.01 and 0 < nRatio then
+		nRatio = 0.01
+	end
+	NovaAPI.SetTMPText(self._mapNode.txtTokenBar, math.floor(nRatio * 100) .. "%")
+	local nBarLength = nMaxBarLength * nRatio
+	self._mapNode.rtTokenBarFill.sizeDelta = Vector2(nBarLength, self._mapNode.rtTokenBarFill.sizeDelta.y)
+end
+function StarTowerAutoDecisionSettingCtrl:SetTime()
+	local curTime = ClientManager.serverTimeStamp
+	NovaAPI.SetTMPText(self._mapNode.txtTime, (os.date("%H:%M", curTime)))
+end
+function StarTowerAutoDecisionSettingCtrl:ShowPhoneTime()
+	self:SetTime()
+	if nil == self.phoneTimer then
+		self.phoneTimer = self:AddTimer(0, 1, "SetTime", true, true, true)
+	end
+end
+function StarTowerAutoDecisionSettingCtrl:Awake()
+	self._mapNode.imgBlurredBg:SetActive(false)
+	self._mapNode.goContentAnim:SetActive(false)
+end
+function StarTowerAutoDecisionSettingCtrl:OnEnable()
+	self._bSettingActive = true
+	self.tbPresetList = nil
+	self.phoneTimer = nil
+	self.nCurSelectIndex = 0
+	if PanelManager.CheckPanelOpen(PanelId.StarTowerFastBattle) then
+		local canvas = self.gameObject:GetComponent("Canvas")
+		NovaAPI.SetCanvasSortingOrder(canvas, AllEnum.UI_SORTING_ORDER.StarTowerAutoDecisionSetting)
+	end
+	GamepadUIManager.EnableGamepadUI("StarTowerAutoDecisionSettingCtrl", {}, nil, true, false, self._panel._nIndex)
+	EventManager.Hit("StarTowerAutoDecisionSettingStateChanged", true)
+	local wait = function()
+		self._mapNode.imgBlurredBg:SetActive(true)
+		coroutine.yield(CS.UnityEngine.WaitForEndOfFrame())
+		if not self._bSettingActive then
+			return
+		end
+		self._mapNode.goContentAnim:SetActive(true)
+		self.nCurSelectIndex = 0
+		local init = function()
+			if not self._bSettingActive then
+				return
+			end
+			self:ShowPhoneTime()
+			self:RefreshTokenValue()
+			self:RefreshPresetList()
+			self:RefreshPresetBase()
+			self:RefreshPresetDetail()
+			self:CacheOriginalServerProject()
+		end
+		PlayerData.StarTowerAutoPlan:EnsureInited(init)
+	end
+	cs_coroutine.start(wait)
+end
+function StarTowerAutoDecisionSettingCtrl:OnDisable()
+	self._bSettingActive = false
+	if self.phoneTimer ~= nil then
+		self.phoneTimer:Cancel()
+		self.phoneTimer = nil
+	end
+	StarTowerSettingGate.ResumeAfterSetting()
+	GamepadUIManager.DisableGamepadUI("StarTowerAutoDecisionSettingCtrl")
+	if self.tbPresetList == nil or self.nCurSelectIndex == nil or self.nCurSelectIndex <= 0 then
+		EventManager.Hit("StarTowerAutoDecisionSettingStateChanged", false)
+		return
+	end
+	for k, v in pairs(self.tbPresetList) do
+		PlayerData.StarTowerAutoPlan:UpdatePlanFromDecisionPlan(v.nPlanId, v)
+		local mapOriginalProject = self.mapOriginalServerProjectByPlanId and self.mapOriginalServerProjectByPlanId[v.nPlanId] or nil
+		local mapCurProject = PlayerData.StarTowerAutoPlan:BuildServerProject(v.nPlanId)
+		local bOriginalDirty = self.mapOriginalDirtyByPlanId and self.mapOriginalDirtyByPlanId[v.nPlanId]
+		if bOriginalDirty ~= true and _IsServerProjectEqual(mapOriginalProject, mapCurProject) then
+			PlayerData.StarTowerAutoPlan:ClearDirty(v.nPlanId)
+		end
+	end
+	PlayerData.StarTowerAutoPlan:SyncDirtyPlans()
+	PlayerData.StarTowerAutoPlan:SendSetSelectedPlanId(self.nCurSelectIndex)
+	EventManager.Hit("StarTowerAutoDecisionSettingStateChanged", false)
+end
+function StarTowerAutoDecisionSettingCtrl:OnBtnClick_Reset()
+	local msg = {
+		nType = AllEnum.MessageBox.Confirm,
+		sTitle = ConfigTable.GetUIText("AutoDecision_ResetConfirmTitle"),
+		sContent = ConfigTable.GetUIText("AutoDecision_ResetConfirm"),
+		callbackConfirm = function()
+			self.tbPresetList[self.nCurSelectIndex] = PlayerData.StarTowerAutoPlan:GetDefaultPlan(self.tbPresetList[self.nCurSelectIndex].nPlanId)
+			self:RefreshPresetDetail()
+			self:RefreshPresetList()
+		end
+	}
+	EventManager.Hit(EventId.OpenMessageBox, msg)
+end
+function StarTowerAutoDecisionSettingCtrl:OnBtnClick_Rename()
+	local cb = function(sNewName)
+		self:RefreshPresetList()
+		self:RefreshPresetDetail()
+	end
+	self._mapNode.goRename:Open(self.tbPresetList[self.nCurSelectIndex], cb)
+end
+function StarTowerAutoDecisionSettingCtrl:OnEvent_CloseAutoDecisionSetting()
+	EventManager.Hit(EventId.ClosePanel, PanelId.StarTowerAutoDecisionSettingPanel)
+end
+function StarTowerAutoDecisionSettingCtrl:OnBtnClick_ClosePanel()
+	self._mapNode.animRoot:Play("PhonePanel_out")
+	local nAnimLength = NovaAPI.GetAnimClipLength(self._mapNode.animRoot, {
+		"PhonePanel_out"
+	})
+	self:AddTimer(1, nAnimLength, function()
+		EventManager.Hit(EventId.ClosePanel, PanelId.StarTowerAutoDecisionSettingPanel)
+	end)
+end
+function StarTowerAutoDecisionSettingCtrl:OnBtnClick_PresetSwitch(_, bOn)
+	self.mapCurPreset.mapPotential.bPresetFirst = bOn
+	if not bOn then
+		self.mapCurPreset.mapPotential.bPresetOnly = false
+		self._mapNode.PresetOnly:SetOn(false)
+	end
+	self._mapNode.PresetOnly:SetEnable(bOn)
+end
+function StarTowerAutoDecisionSettingCtrl:OnBtnClick_PresetOnlySwitch(_, bOn)
+	self.mapCurPreset.mapPotential.bPresetOnly = bOn
+end
+function StarTowerAutoDecisionSettingCtrl:OnBtnClick_PotentialSort(_, tbCurSelect)
+	self.mapCurPreset.mapPotential.tbPotentialSort = tbCurSelect
+end
+function StarTowerAutoDecisionSettingCtrl:OnBtnClick_PotentialRerollSwitch(_, bOn)
+	self.mapCurPreset.mapPotential.bPotentialReroll = bOn
+	self._mapNode.PotentialRerollCoin:SetGray(not bOn)
+end
+function StarTowerAutoDecisionSettingCtrl:OnBtnClick_PotentialRerollCoin(_, nAmount)
+	self.mapCurPreset.mapPotential.nPotentialRerollCoinNum = nAmount
+end
+function StarTowerAutoDecisionSettingCtrl:OnBtnClick_ShopChoose(_, nChosenIndex)
+	self.mapCurPreset.mapShop.nShopFirst = nChosenIndex
+end
+function StarTowerAutoDecisionSettingCtrl:OnEvent_ShopDropdown(nDropdownValue)
+	local nOptionIndex = nDropdownValue + 1
+	local nUpgradePrice = tonumber(self.tbDropdownOption[nOptionIndex])
+	if nUpgradePrice ~= nil then
+		self.mapCurPreset.mapShop.nShopUpgradePrice = nUpgradePrice
+	end
+end
+function StarTowerAutoDecisionSettingCtrl:OnBtnClick_ShopSort(_, tbCurSelect)
+	self.mapCurPreset.mapShop.tbShopSort = tbCurSelect
+end
+function StarTowerAutoDecisionSettingCtrl:OnBtnClick_ShopRefreshSwitch(_, bOn)
+	self.mapCurPreset.mapShop.bShopCoinReroll = bOn
+	self._mapNode.ShopCoin:SetGray(not bOn)
+end
+function StarTowerAutoDecisionSettingCtrl:OnBtnClick_ShopFinalAllInSwitch(_, bOn)
+	self.mapCurPreset.mapShop.bShopFinalAllIn = bOn
+end
+function StarTowerAutoDecisionSettingCtrl:OnBtnClick_ShopCoin(_, nAmount)
+	self.mapCurPreset.mapShop.nShopCoinNum = nAmount
+end
+function StarTowerAutoDecisionSettingCtrl:OnBtnClick_ShopFinalRerollSwitch(_, bOn)
+	self.mapCurPreset.mapShop.bShopFinalReroll = bOn
+end
+function StarTowerAutoDecisionSettingCtrl:OnBtnClick_TendencySelect(_, nChosenIndex)
+	self.mapCurPreset.mapEvent.nEventTendency = nChosenIndex
+end
+function StarTowerAutoDecisionSettingCtrl:OnBtnClick_EventSort(_, tbCurSelect)
+	self.mapCurPreset.mapEvent.tbEventSort = tbCurSelect
+end
+function StarTowerAutoDecisionSettingCtrl:OnBtnClick_AddToken()
+	EventManager.Hit(EventId.OpenPanel, PanelId.StarTowerTokenBuyPanel)
+end
+return StarTowerAutoDecisionSettingCtrl

lua/game/ui/startowerfastbattle/startowerautodecisionsettingpanel.lua

@@ -0,0 +1,17 @@
+local StarTowerAutoDecisionSettingPanel = class("StarTowerAutoDecisionSettingPanel", BasePanel)
+StarTowerAutoDecisionSettingPanel._bIsMainPanel = false
+StarTowerAutoDecisionSettingPanel._tbDefine = {
+	{
+		sPrefabPath = "StarTowerFastBattle/StarTowerAutoBattlePanel.prefab",
+		sCtrlName = "Game.UI.StarTowerFastBattle.StarTowerAutoDecisionSettingCtrl"
+	}
+}
+function StarTowerAutoDecisionSettingPanel:Awake()
+end
+function StarTowerAutoDecisionSettingPanel:OnEnable()
+end
+function StarTowerAutoDecisionSettingPanel:OnDisable()
+end
+function StarTowerAutoDecisionSettingPanel:OnDestroy()
+end
+return StarTowerAutoDecisionSettingPanel

lua/game/ui/startowerfastbattle/startowerfastbattlectrl.lua

@@ -1,4 +1,5 @@
 local StarTowerFastBattleCtrl = class("StarTowerFastBattleCtrl", BaseCtrl)
+local StarTowerSettingGate = require("Game.Adventure.StarTower.StarTowerSettingGate")
 local LocalSettingData = require("GameCore.Data.LocalSettingData")
 local Actor2DManager = require("Game.Actor2D.Actor2DManager")
 local GamepadUIManager = require("GameCore.Module.GamepadUIManager")
@@ -124,7 +125,12 @@ StarTowerFastBattleCtrl._mapEventConfig = {
 	RefreshNoteCount = "OnEvent_RefreshNoteCount",
 	TryCloseStarTowerLastShop = "OnEvent_TryCloseStarTowerLastShop",
 	ShowNPCAffinity = "OnEvent_AffinityTips",
-	LeaveStarTowerFastBattle = "OnEvent_Leave"
+	LeaveStarTowerFastBattle = "OnEvent_Leave",
+	StarTowerFastBattleLeaveForRecharge = "OnEvent_LeaveForRecharge",
+	StarTowerAutoDecisionStateChanged = "OnEvent_AutoDecisionStateChanged",
+	StarTowerAutoDecisionRequestManual = "OnEvent_AutoDecisionRequestManual",
+	StarTowerAutoDecisionRequestFailed = "OnEvent_AutoDecisionRequestFailed",
+	StarTowerFastBattleOptionReady = "OnEvent_StarTowerFastBattleOptionReady"
 }
 StarTowerFastBattleCtrl._mapRedDotConfig = {}
 local theme_sprite_path = "UI/big_sprites/"
@@ -140,7 +146,7 @@ local room_bg = {
 function StarTowerFastBattleCtrl:Awake()
 	self.bHandleOver = false
 	self.bOpenOption = false
-	self.bAuto = true
+	self.bAutoAdvance = true
 	self.bPause = false
 	self.nNextCaseId = -1
 	self.nNextRoomType = -1
@@ -164,6 +170,11 @@ end
 function StarTowerFastBattleCtrl:FadeOut()
 end
 function StarTowerFastBattleCtrl:OnEnable()
+	StarTowerSettingGate.Begin()
+	StarTowerSettingGate.Transition(self, 1.3)
+	self.bAutoAdvance = true
+	self.bPause = false
+	self:RefreshPauseStatus()
 	self:InitGroupTheme()
 	self:RefreshRoomFloor()
 	self:RefreshRoomBg()
@@ -179,12 +190,24 @@ function StarTowerFastBattleCtrl:OnEnable()
 	GamepadUIManager.EnableGamepadUI("StarTowerFastBattleCtrl", {}, nil, true)
 end
 function StarTowerFastBattleCtrl:OnDisable()
+	StarTowerSettingGate.Clear(self)
+	self._panel.LevelData:SetAutoDecisionEnabled(false)
 	self.nNextCaseId = -1
 	self.nNextRoomType = -1
 	self.tbHistoryLog = nil
 	GamepadUIManager.DisableGamepadUI("StarTowerFastBattleCtrl")
 end
 function StarTowerFastBattleCtrl:OnDestroy()
+	local func_OpenRecharge = self._func_OpenRechargeAfterLeave
+	self._func_OpenRechargeAfterLeave = nil
+	if type(func_OpenRecharge) == "function" then
+		cs_coroutine.start(function()
+			coroutine.yield(CS.UnityEngine.WaitForEndOfFrame())
+			if PanelManager.GetCurPanelId() == PanelId.MainView and not PanelManager.CheckPanelOpen(PanelId.StarTowerFastBattle) and not PanelManager.CheckNextPanelOpening() then
+				func_OpenRecharge()
+			end
+		end)
+	end
 end
 function StarTowerFastBattleCtrl:OnRelease()
 end
@@ -209,6 +232,10 @@ function StarTowerFastBattleCtrl:Init()
 	self:RefreshPauseStatus()
 end
 function StarTowerFastBattleCtrl:StartFastBattle()
+	StarTowerSettingGate.Begin()
+	StarTowerSettingGate.Transition(self, NovaAPI.GetAnimClipLength(self.Animator, {
+		"StarTowerFastBattlePanel_open"
+	}))
 	EventManager.Hit("InitStarTowerNote", self._panel.LevelData._mapNote)
 	self.Animator:Play("StarTowerFastBattlePanel_open")
 	CS.WwiseAudioManager.Instance:PlaySound("ui_startower_fastBattle_elevator_door")
@@ -217,8 +244,9 @@ function StarTowerFastBattleCtrl:StartFastBattle()
 	end, true, true, true)
 end
 function StarTowerFastBattleCtrl:EnterRoom()
-	self.bHandleOver = false
-	self._panel.LevelData:EnterRoom(self.nNextCaseId, self.nNextRoomType)
+	if self._panel.LevelData:EnterRoom(self.nNextCaseId, self.nNextRoomType) then
+		self.bHandleOver = false
+	end
 end
 function StarTowerFastBattleCtrl:InitGroupTheme()
 	local mapStarTowerCfg = ConfigTable.GetData("StarTower", self._panel.nStarTowerId)
@@ -313,6 +341,7 @@ function StarTowerFastBattleCtrl:RefreshBuildScore()
 	local nLastScore = tonumber(NovaAPI.GetTMPText(self._mapNode.textBulidScoreNum))
 	local nAfterScore = self._panel.LevelData:CalBuildScore()
 	if nAfterScore ~= nLastScore then
+		StarTowerSettingGate.Transition(self, 1)
 		local twCoin = DOTween.To(function()
 			return nLastScore
 		end, function(score)
@@ -404,20 +433,29 @@ function StarTowerFastBattleCtrl:GetTeamNeedExpByLevel(nGroupId, nLevel)
 	return nNeedExp, bMaxLevel
 end
 function StarTowerFastBattleCtrl:LeaveStarTower(callback)
+	if self._panel.LevelData.bEnd then
+		return
+	end
 	local msg = {
 		nType = AllEnum.MessageBox.Confirm,
 		sContent = ConfigTable.GetUIText("StarTower_Sweep_BackTips_Content"),
 		sConfirm = ConfigTable.GetUIText("StarTower_Sweep_Leave_Btn"),
 		sCancel = ConfigTable.GetUIText("StarTower_Sweep_GiveUp_Btn"),
 		callbackConfirm = function()
+			if self._panel.LevelData.bEnd then
+				return
+			end
+			self._panel.LevelData:StarTowerLeave()
 			if callback ~= nil then
 				callback()
 			end
-			self._panel.LevelData:StarTowerLeave()
 			PanelManager.Home()
 		end,
 		callbackCancel = function()
 			local giveUpCallBack = function()
+				if not self._panel.LevelData:EndExploration() then
+					return
+				end
 				local mapStarTowerState = PlayerData.State:GetStarTowerState()
 				PlayerData.StarTower:GiveUpReconnect(mapStarTowerState.Id, mapStarTowerState.CharIds, false, function()
 					local wait = function()
@@ -445,22 +483,59 @@ function StarTowerFastBattleCtrl:LeaveStarTower(callback)
 end
 function StarTowerFastBattleCtrl:OnHandleCasesOver()
 	local CurHandleCasesOver = function()
-		self.bOpenOption = false
-		self.Animator:Play("StarTowerFastBattlePanel_idle")
-		if self.bAuto and not self.bPause then
-			self:EnterRoom()
-		end
+		self:ContinueAfterShop()
 	end
 	local bShop, bMachine, nMachineCount, nDiscount, bFirstFree = self._panel.LevelData:GetShopAndMachine()
 	if bShop or bMachine then
-		self.bOpenOption = true
-		local bLastShopRoom = self._panel.LevelData:CheckLastShopRoom()
-		local nItemCount = self._panel.LevelData._mapItem[AllEnum.CoinItemId.FixedRogCurrency] or 0
-		EventManager.Hit(EventId.OpenPanel, PanelId.StarTowerFastBattleOption, bShop, bMachine, nMachineCount, nItemCount, CurHandleCasesOver, nDiscount, bFirstFree, bLastShopRoom)
+		self:OpenShopOption(CurHandleCasesOver, bShop, bMachine, nMachineCount, nDiscount, bFirstFree)
 	else
 		CurHandleCasesOver()
 	end
 end
+function StarTowerFastBattleCtrl:ContinueAfterShop()
+	if self._panel.LevelData.bEnd then
+		return
+	end
+	self.bOpenOption = false
+	self.Animator:Play("StarTowerFastBattlePanel_idle")
+	if self.bAutoAdvance and not self.bPause then
+		self:EnterRoom()
+	else
+		StarTowerSettingGate.Ready(self, StarTowerSettingGate.Begin())
+	end
+end
+function StarTowerFastBattleCtrl:OpenShopOption(closeCallback, bShop, bMachine, nMachineCount, nDiscount, bFirstFree)
+	StarTowerSettingGate.Begin()
+	self.bOpenOption = true
+	if bShop == nil then
+		bShop, bMachine, nMachineCount, nDiscount, bFirstFree = self._panel.LevelData:GetShopAndMachine()
+	end
+	if bShop or bMachine then
+		local bLastShopRoom = self._panel.LevelData:CheckLastShopRoom()
+		local nItemCount = self._panel.LevelData._mapItem[AllEnum.CoinItemId.FixedRogCurrency] or 0
+		local bAutoDisplay = self._panel.LevelData:IsAutoDecisionEnabled()
+		EventManager.Hit(EventId.OpenPanel, PanelId.StarTowerFastBattleOption, bShop, bMachine, nMachineCount, nItemCount, closeCallback, nDiscount, bFirstFree, bLastShopRoom, bAutoDisplay)
+	end
+end
+function StarTowerFastBattleCtrl:TryResumeAutoShopOption()
+	if not self.bOpenOption or not self._panel.LevelData:IsAutoDecisionEnabled() then
+		return false
+	end
+	if self._panel.LevelData:IsAutoDecisionBusy() then
+		return true
+	end
+	return self._panel.LevelData:TryAutoShopEntry(function()
+		local bPanelOpen, bPanelActive = PanelManager.CheckPanelOpen(PanelId.StarTowerFastBattleOption)
+		if bPanelOpen and bPanelActive then
+			EventManager.Hit(EventId.ClosePanel, PanelId.StarTowerFastBattleOption)
+		else
+			self:ContinueAfterShop()
+		end
+	end)
+end
+function StarTowerFastBattleCtrl:OnEvent_StarTowerFastBattleOptionReady()
+	self:TryResumeAutoShopOption()
+end
 function StarTowerFastBattleCtrl:OnBackButtonClick()
 	if not self.bHandleOver then
 		return
@@ -495,17 +570,32 @@ function StarTowerFastBattleCtrl:OnNoteDetailsButtonClick()
 	EventManager.Hit("OpenStarTowerDepot", LevelData._mapPotential, LevelData._mapNote, LevelData._mapFateCard, LevelData._mapItem, LevelData.tbActiveSecondaryIds, AllEnum.StarTowerDepotTog.DiscSkill)
 end
 function StarTowerFastBattleCtrl:OnFastBattleButtonClick()
+	if self.bPause and PanelManager.CheckPanelOpen(PanelId.StarTowerAutoDecisionSettingPanel) then
+		return
+	end
 	self.bPause = not self.bPause
+	self._panel.LevelData:SetAutoDecisionPaused(self.bPause)
 	self:RefreshPauseStatus(true)
+	if self.bPause and self.bHandleOver and not self.bOpenOption then
+		StarTowerSettingGate.Ready(self, StarTowerSettingGate.Begin())
+	end
 	if not self.bHandleOver or self.bPause then
 		return
 	end
+	if self.bOpenOption then
+		self:TryResumeAutoShopOption()
+		return
+	end
 	if self.nNextCaseId < 0 or 0 > self.nNextRoomType then
 		return
 	end
 	self:EnterRoom()
 end
 function StarTowerFastBattleCtrl:OnEvent_InitRoom()
+	StarTowerSettingGate.Begin()
+	StarTowerSettingGate.Transition(self, 0.1 + math.max(1, NovaAPI.GetAnimClipLength(self.Animator, {
+		"StarTowerFastBattlePanel_up"
+	})))
 	self.Animator:Play("StarTowerFastBattlePanel_close")
 	self:AddTimer(1, 0.1, function()
 		CS.WwiseAudioManager.Instance:PlaySound("ui_startower_fastBattle_elevator")
@@ -525,20 +615,22 @@ function StarTowerFastBattleCtrl:OnEvent_InitRoom()
 	end, true, true, true)
 end
 function StarTowerFastBattleCtrl:OnEvent_EventHandleOver()
-	if self.bOpenOption then
-		return
-	end
 	self.bHandleOver = true
 	self.nNextCaseId, self.nNextRoomType = self._panel.LevelData:GetDoorCase()
+	if self.bOpenOption then
+		self:TryResumeAutoShopOption()
+		return
+	end
 	self:OnHandleCasesOver()
 end
 function StarTowerFastBattleCtrl:OnEvent_EnterDangerRoom(nCaseId, nRoomType)
-	if self.bOpenOption then
-		return
-	end
 	self.bHandleOver = true
 	self.nNextCaseId = nCaseId
 	self.nNextRoomType = nRoomType
+	if self.bOpenOption then
+		self:TryResumeAutoShopOption()
+		return
+	end
 	self:OnHandleCasesOver()
 end
 function StarTowerFastBattleCtrl:OnEvent_RefreshFastBattleInfo(tbChangeFateCard, mapChangeNote, mapItemChange, nLevelChange, nExpChange, mapPotentialChange)
@@ -595,20 +687,20 @@ function StarTowerFastBattleCtrl:OnEvent_RefreshFastBattleInfo(tbChangeFateCard,
 		self.tbTips = {}
 	end
 end
-function StarTowerFastBattleCtrl:OnEvent_StarTowerFastBattleOpenShop()
+function StarTowerFastBattleCtrl:OnEvent_StarTowerFastBattleOpenShop(bAuto)
 	if not self.bOpenOption then
 		return
 	end
-	local bSuccess = self._panel.LevelData:OpenShop()
+	local bSuccess = self._panel.LevelData:OpenShop(bAuto)
 	if not bSuccess then
 		printError("打开商店界面失败")
 	end
 end
-function StarTowerFastBattleCtrl:OnEvent_StarTowerFastBattleOpenMachine()
+function StarTowerFastBattleCtrl:OnEvent_StarTowerFastBattleOpenMachine(bAuto)
 	if not self.bOpenOption then
 		return
 	end
-	local bSuccess = self._panel.LevelData:OpenStrengthMachine()
+	local bSuccess = self._panel.LevelData:OpenStrengthMachine(bAuto)
 	if not bSuccess then
 		printError("打开强化界面失败")
 	end
@@ -659,4 +751,56 @@ end
 function StarTowerFastBattleCtrl:OnEvent_Leave(callback)
 	self:LeaveStarTower(callback)
 end
+function StarTowerFastBattleCtrl:OnEvent_LeaveForRecharge(callback)
+	self._panel.LevelData:StarTowerLeave()
+	self._func_OpenRechargeAfterLeave = callback
+	PanelManager.Home()
+end
+function StarTowerFastBattleCtrl:OnEvent_AutoDecisionStateChanged(mapState)
+	if self._panel.LevelData.bEnd then
+		return
+	end
+	if type(mapState) ~= "table" or mapState.bEnabled ~= true or mapState.bPaused == true then
+		return
+	end
+	if self.bAutoAdvance and not self.bPause then
+		return
+	end
+	self.bAutoAdvance = true
+	self.bPause = false
+	self:RefreshPauseStatus()
+end
+function StarTowerFastBattleCtrl:OnEvent_AutoDecisionRequestFailed(objLevelData)
+	if self._panel.LevelData ~= objLevelData or objLevelData.bEnd then
+		return
+	end
+	self.bPause = true
+	self:RefreshPauseStatus()
+	if not objLevelData:HasPendingCases() then
+		local bShop, bMachine = objLevelData:GetShopAndMachine()
+		if bShop or bMachine then
+			self:OnEvent_AutoDecisionRequestManual()
+		end
+	end
+end
+function StarTowerFastBattleCtrl:OnEvent_AutoDecisionRequestManual()
+	local bNpcOptionOpen = PanelManager.CheckPanelOpen(PanelId.NpcOptionPanel)
+	if bNpcOptionOpen then
+		return
+	end
+	if self._panel.LevelData:HasPendingCases() then
+		self._panel.LevelData:HandleCases()
+		return
+	end
+	local bShop, bMachine = self._panel.LevelData:GetShopAndMachine()
+	if bShop or bMachine then
+		if not self.bOpenOption then
+			self:OpenShopOption(function()
+				self:ContinueAfterShop()
+			end)
+		end
+		return
+	end
+	self._panel.LevelData:HandleCases()
+end
 return StarTowerFastBattleCtrl

lua/game/ui/startowerfastbattle/startowerfastbattlelogctrl.lua

@@ -33,6 +33,9 @@ function StarTowerFastBattleLogCtrl:Awake()
 	self._mapNode.goWindow:SetActive(false)
 end
 function StarTowerFastBattleLogCtrl:OnEnable()
+	local canvas = self.gameObject:GetComponent("Canvas")
+	NovaAPI.SetCanvasOverrideSorting(canvas, true)
+	NovaAPI.SetCanvasSortingOrder(canvas, AllEnum.UI_SORTING_ORDER.StarTowerAutoDecisionHUD + 1)
 	self._mapNode.goBlur:SetActive(true)
 	local wait = function()
 		coroutine.yield(CS.UnityEngine.WaitForEndOfFrame())

lua/game/ui/startowerfastbattle/startowerfastbattlelogpanel.lua

@@ -1,5 +1,6 @@
 local StarTowerFastBattleLogPanel = class("StarTowerFastBattleLogPanel", BasePanel)
 StarTowerFastBattleLogPanel._bIsMainPanel = false
+StarTowerFastBattleLogPanel._sSortingLayerName = AllEnum.SortingLayerName.UI_Top
 StarTowerFastBattleLogPanel._tbDefine = {
 	{
 		sPrefabPath = "StarTowerFastBattle/StarTowerFastBattleLogPanel.prefab",

lua/game/ui/startowerfastbattle/startowerfastbattleoptionctrl.lua

@@ -1,5 +1,6 @@
 local StarTowerFastBattleOptionCtrl = class("StarTowerFastBattleOptionCtrl", BaseCtrl)
 local GamepadUIManager = require("GameCore.Module.GamepadUIManager")
+local StarTowerSettingGate = require("Game.Adventure.StarTower.StarTowerSettingGate")
 StarTowerFastBattleOptionCtrl._mapNodeConfig = {
 	goBlur = {
 		sNodeName = "t_fullscreen_blur_blue"
@@ -36,7 +37,11 @@ StarTowerFastBattleOptionCtrl._mapEventConfig = {
 	RefreshStrengthMachineCost = "OnEvent_RefreshStrengthMachineCost",
 	RefreshStarTowerCoin = "OnEvent_RefreshStarTowerCoin",
 	GamepadUIChange = "OnEvent_GamepadUIChange",
-	GamepadUIReopen = "OnEvent_Reopen"
+	GamepadUIReopen = "OnEvent_Reopen",
+	StarTowerAutoPreviewShopOption = "OnEvent_AutoPreviewShopOption",
+	StarTowerAutoExecuteShopOption = "OnEvent_AutoExecuteShopOption",
+	StarTowerAutoDecisionStateChanged = "OnEvent_AutoDecisionStateChanged",
+	StarTowerSweepEnd = "OnEvent_StarTowerSweepEnd"
 }
 function StarTowerFastBattleOptionCtrl:Awake()
 	self._mapNode.goBlur:SetActive(false)
@@ -54,19 +59,25 @@ function StarTowerFastBattleOptionCtrl:Awake()
 	self.tbStrengthMachineCost = ConfigTable.GetConfigNumberArray("StrengthenMachineGoldConsume")
 end
 function StarTowerFastBattleOptionCtrl:OnEnable()
+	local nSettingSerial = StarTowerSettingGate.Begin()
 	self.handler = {}
 	for k, v in ipairs(self._mapNode.btnChoose) do
 		self.handler[k] = ui_handler(self, self.OnBtnSelect_Select, v, k)
 		v.onSelect:AddListener(self.handler[k])
 	end
 	self.nSelectIdx = 0
+	self.bAutoSelecting = false
 	self.closeCallBack = self._panel.closeCallback
 	self._mapNode.goBlur:SetActive(true)
 	local wait = function()
 		coroutine.yield(CS.UnityEngine.WaitForEndOfFrame())
 		self:Refresh()
 		self._mapNode.rtSelectOption:SetActive(true)
+		if self._panel.bAutoDisplay then
+			EventManager.Hit("StarTowerFastBattleOptionReady")
+		end
 		EventManager.Hit(EventId.TemporaryBlockInput, 1)
+		StarTowerSettingGate.ReadyAfter(self, nSettingSerial, 1)
 	end
 	cs_coroutine.start(wait)
 	GamepadUIManager.EnableGamepadUI("StarTowerFastBattleOptionCtrl", self:GetGamepadUINode())
@@ -74,17 +85,22 @@ function StarTowerFastBattleOptionCtrl:OnEnable()
 	NovaAPI.SetTMPText(self._mapNode.textCoinCount, self:ThousandsNumber(self._panel.nCoinCount))
 end
 function StarTowerFastBattleOptionCtrl:OnDisable()
+	StarTowerSettingGate.Clear(self)
 	GamepadUIManager.DisableGamepadUI("StarTowerFastBattleOptionCtrl")
-	if self.closeCallBack ~= nil and type(self.closeCallBack) == "function" then
-		self.closeCallBack()
-	end
+	local closeCallback = self.closeCallBack
 	self.closeCallBack = nil
+	if type(closeCallback) == "function" then
+		closeCallback()
+	end
 	for k, v in ipairs(self._mapNode.btnChoose) do
 		v.onSelect:RemoveListener(self.handler[k])
 	end
 end
 function StarTowerFastBattleOptionCtrl:OnDestroy()
 end
+function StarTowerFastBattleOptionCtrl:OnEvent_StarTowerSweepEnd()
+	self.closeCallBack = nil
+end
 function StarTowerFastBattleOptionCtrl:Refresh()
 	self._mapNode.rtChoose[1]:SetActive(self._panel.bShop)
 	NovaAPI.SetTMPText(self._mapNode.TMPChoose[1], ConfigTable.GetUIText("StarTower_Sweep_Option_1"))
@@ -137,18 +153,56 @@ function StarTowerFastBattleOptionCtrl:RefreshMachineCost()
 	local sCost = self.nMachineCost == 0 and ConfigTable.GetUIText("ST_StrengthenMachine_Free") or tostring(self.nMachineCost)
 	NovaAPI.SetTMPText(self._mapNode.TMPChoose[2], orderedFormat(ConfigTable.GetUIText("StarTower_Sweep_Option_2"), self._panel.nCoinCount < self.nMachineCost and "#BD3059" or "#264278", sCost))
 end
-function StarTowerFastBattleOptionCtrl:OnBtnClick_Select(btn)
+function StarTowerFastBattleOptionCtrl:OnBtnClick_Select(btn, bAuto)
+	if self.bAutoSelecting and bAuto ~= true then
+		return
+	end
 	local nIdx = table.indexof(self._mapNode.btnChoose, btn)
+	if nIdx == 1 or nIdx == 2 or nIdx == 3 then
+		StarTowerSettingGate.Begin()
+	end
 	if nIdx == 1 then
-		EventManager.Hit("StarTowerFastBattleOpenShop")
+		EventManager.Hit("StarTowerFastBattleOpenShop", bAuto == true)
 	elseif nIdx == 2 then
-		EventManager.Hit("StarTowerFastBattleOpenMachine")
+		EventManager.Hit("StarTowerFastBattleOpenMachine", bAuto == true)
 	elseif nIdx == 3 then
 		EventManager.Hit(EventId.ClosePanel, PanelId.StarTowerFastBattleOption)
 	elseif nIdx == 5 then
 		EventManager.Hit("TryCloseStarTowerLastShop", self._panel.bMachine, self.nMachineCost)
 	end
 end
+function StarTowerFastBattleOptionCtrl:OnEvent_AutoPreviewShopOption(nIndex)
+	if not self:IsOptionAvailable(nIndex) then
+		return
+	end
+	self.bAutoSelecting = true
+	for k, selectNode in ipairs(self._mapNode.Select) do
+		selectNode:SetActive(k == nIndex)
+	end
+	self.nSelectIdx = nIndex
+	GamepadUIManager.SetSelectedUI(self._mapNode.btnChoose[nIndex].gameObject)
+end
+function StarTowerFastBattleOptionCtrl:OnEvent_AutoExecuteShopOption(nIndex)
+	if not self:IsOptionAvailable(nIndex) then
+		return
+	end
+	self.bAutoSelecting = false
+	self:OnBtnClick_Select(self._mapNode.btnChoose[nIndex], true)
+end
+function StarTowerFastBattleOptionCtrl:OnEvent_AutoDecisionStateChanged(mapState)
+	if type(mapState) == "table" and mapState.bPending ~= true then
+		self.bAutoSelecting = false
+	end
+end
+function StarTowerFastBattleOptionCtrl:IsOptionAvailable(nIndex)
+	if nIndex == 1 then
+		return self._panel.bShop == true
+	end
+	if nIndex == 2 then
+		return self._panel.bMachine == true
+	end
+	return false
+end
 function StarTowerFastBattleOptionCtrl:OnEvent_RefreshStrengthMachineCost(nMachineCount, bFirstFree)
 	self._panel.nMachineCount = nMachineCount
 	self._panel.bFirstFree = bFirstFree
@@ -183,6 +237,7 @@ function StarTowerFastBattleOptionCtrl:OnBtnClick_Back()
 	end)
 end
 function StarTowerFastBattleOptionCtrl:OnBtnClick_Depot()
+	StarTowerSettingGate.Begin()
 	EventManager.Hit("StarTowerSetButtonEnable", false, false)
 	self._mapNode.trRoot.gameObject:SetActive(false)
 	self._mapNode.goBlur.gameObject:SetActive(false)
@@ -210,11 +265,13 @@ function StarTowerFastBattleOptionCtrl:OnEvent_Reopen(sName)
 	if sName ~= "StarTowerFastBattleOptionCtrl" then
 		return
 	end
+	local nSettingSerial = StarTowerSettingGate.Begin()
 	self._mapNode.goBlur.gameObject:SetActive(true)
 	self._mapNode.trRoot.gameObject:SetActive(true)
 	local nSelect = self.nSelectIdx ~= 0 and self.nSelectIdx or 3
 	GamepadUIManager.SetSelectedUI(self._mapNode.btnChoose[nSelect].gameObject)
 	self:SelectChoose()
+	StarTowerSettingGate.ReadyAfter(self, nSettingSerial, 1)
 end
 function StarTowerFastBattleOptionCtrl:SelectChoose()
 	local nUIType = GamepadUIManager.GetCurUIType()

lua/game/ui/startowerfastbattle/startowerfastbattleoptionpanel.lua

@@ -17,6 +17,7 @@ function StarTowerFastBattleOptionPanel:Awake()
 		self.nDiscount = tbParams[6]
 		self.bFirstFree = tbParams[7]
 		self.bLastFloor = tbParams[8]
+		self.bAutoDisplay = tbParams[9] == true
 	end
 end
 function StarTowerFastBattleOptionPanel:OnEnable()

lua/game/ui/startowerfastbattle/startowerfastbattlepanel.lua

@@ -1,5 +1,6 @@
 local StarTowerFastBattlePanel = class("StarTowerFastBattlePanel", BasePanel)
 local GamepadUIManager = require("GameCore.Module.GamepadUIManager")
+local StarTowerSettingGate = require("Game.Adventure.StarTower.StarTowerSettingGate")
 StarTowerFastBattlePanel._tbDefine = {
 	{
 		sPrefabPath = "StarTowerFastBattle/StarTowerFastBattlePanel.prefab",
@@ -28,6 +29,10 @@ StarTowerFastBattlePanel._tbDefine = {
 	{
 		sPrefabPath = "StarTower/StarTowerDepotPanel.prefab",
 		sCtrlName = "Game.UI.StarTower.Depot.StarTowerDepotCtrl"
+	},
+	{
+		sPrefabPath = "StarTowerFastBattle/StarTowerAutoBattlePopup.prefab",
+		sCtrlName = "Game.UI.StarTowerFastBattle.StarTowerAutoDecisionHUDCtrl"
 	}
 }
 function StarTowerFastBattlePanel:Awake()
@@ -37,6 +42,7 @@ function StarTowerFastBattlePanel:Awake()
 	local tbStarTowerInfo = tbParams[1]
 	local luaClass = require("Game.Adventure.StarTower.StarTowerSweepData")
 	self.LevelData = luaClass.new(tbStarTowerInfo.Meta.Id)
+	StarTowerSettingGate.Start(self.LevelData)
 	self.LevelData:Init(tbStarTowerInfo.Meta, tbStarTowerInfo.Room, tbStarTowerInfo.Bag)
 	EventManager.Hit("SetStarTowerSweepData", self.LevelData)
 	self.tbTeam = self.LevelData.tbTeam
@@ -78,18 +84,12 @@ function StarTowerFastBattlePanel:Awake()
 	GamepadUIManager.EnterAdventure(true)
 end
 function StarTowerFastBattlePanel:SetTop(goCanvas)
-	local nTopLayer = 0
-	if nil ~= self.trUIRoot then
-		local nChildCount = self.trUIRoot.childCount
-		local trChild
-		for i = 1, nChildCount do
-			trChild = self.trUIRoot:GetChild(i - 1)
-			nTopLayer = math.max(nTopLayer, NovaAPI.GetCanvasSortingOrder(trChild:GetComponent("Canvas")))
-		end
-	end
-	if 0 < nTopLayer then
-		NovaAPI.SetCanvasSortingOrder(goCanvas, nTopLayer + 1)
-	end
+	NovaAPI.SetCanvasSortingOrder(goCanvas, AllEnum.UI_SORTING_ORDER.StarTowerSweepPopup)
+end
+function StarTowerFastBattlePanel:OpenDepotDetailPanel(nPanelId, ...)
+	PanelManager.OpenPanelWithContext(nPanelId, {
+		nSortingOrderBase = AllEnum.UI_SORTING_ORDER.StarTowerSweepDetail
+	}, ...)
 end
 function StarTowerFastBattlePanel:CheckMainChar(nCharId)
 	if self.tbTeam ~= nil then
@@ -121,10 +121,13 @@ function StarTowerFastBattlePanel:OnEnable()
 	cs_coroutine.start(wait)
 end
 function StarTowerFastBattlePanel:OnDisable()
+	StarTowerSettingGate.Stop(self.LevelData)
 	PlayerData.State:SetStarTowerSweepState(false)
 	GamepadUIManager.QuitAdventure()
 end
 function StarTowerFastBattlePanel:OnDestroy()
+	StarTowerSettingGate.Stop(self.LevelData)
+	self.LevelData:EndExploration()
 	self.LevelData:UnBindEvent()
 	EventManager.Hit("SetStarTowerSweepData")
 end

lua/game/ui/startowerfastbattle/startowertokenbuyconfirmctrl.lua

@@ -0,0 +1,190 @@
+local StarTowerTokenBuyConfirmCtrl = class("StarTowerTokenBuyConfirmCtrl", BaseCtrl)
+local LayoutRebuilder = CS.UnityEngine.UI.LayoutRebuilder
+StarTowerTokenBuyConfirmCtrl._mapNodeConfig = {
+	goWindow = {},
+	animWindow = {sNodeName = "goWindow", sComponentName = "Animator"},
+	txtWindowTitle = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "TokenBuy_Confirm_Title"
+	},
+	btnClose = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_Close"
+	},
+	imgCoin = {sComponentName = "Image"},
+	txtCoinCount = {sComponentName = "TMP_Text"},
+	imgToken = {sComponentName = "Image"},
+	txtTokenCount = {sComponentName = "TMP_Text"},
+	txtHave = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "TokenBuy_Confirm_Text"
+	},
+	txtBeforeValue = {sComponentName = "TMP_Text"},
+	txtAfterValue = {sComponentName = "TMP_Text"},
+	goMaxValue = {},
+	txtMaxValue = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Energy_Count_Max"
+	},
+	rtGoValue = {
+		sNodeName = "goValue",
+		sComponentName = "RectTransform"
+	},
+	rtCountBg = {
+		sNodeName = "imgCountBg",
+		sComponentName = "RectTransform"
+	},
+	btnCancel = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_Cancel"
+	},
+	btnConfirm1 = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_Confirm"
+	},
+	txtCancelBtn = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Energy_Buy_Cancel_Btn_Text"
+	},
+	txtConfirmBtn = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Energy_Buy_Confirm_Btn_Text"
+	},
+	goQuantitySelector = {
+		sNodeName = "tc_quantity_selector",
+		sCtrlName = "Game.UI.TemplateEx.TemplateQuantitySelectorCtrl"
+	}
+}
+StarTowerTokenBuyConfirmCtrl._mapEventConfig = {}
+function StarTowerTokenBuyConfirmCtrl:Awake()
+end
+function StarTowerTokenBuyConfirmCtrl:OnEnable()
+end
+function StarTowerTokenBuyConfirmCtrl:ShowPanel()
+	self._mapNode.animWindow:Play("t_window_04_t_in")
+	EventManager.Hit(EventId.TemporaryBlockInput, 0.3)
+	self.nBuyCount = 1
+	self.nTokenEveryBuy = ConfigTable.GetConfigNumber("TowerVitaEnergyPurchasedValue")
+	local mapVitaTokenPrice = ConfigTable.GetConfigArray("TowerVitaEnergyPurchasedPrice")
+	self.nTokenPrice = tonumber(mapVitaTokenPrice[2])
+	self.nCoinId = tonumber(mapVitaTokenPrice[1])
+	self.nMaxToken = self._panel.nMaxToken or ConfigTable.GetConfigNumber("TowerVitaEnergyMax")
+	self:RefreshMaxBuy()
+	self:RefreshAddCount()
+end
+function StarTowerTokenBuyConfirmCtrl:OnDisable()
+end
+function StarTowerTokenBuyConfirmCtrl:OnDestroy()
+end
+function StarTowerTokenBuyConfirmCtrl:RefreshMaxBuy()
+	self.nCurTokenCount = PlayerData.StarTowerAutoPlan:GetTokenCount()
+	self.nMaxBuy = math.ceil((self.nMaxToken - self.nCurTokenCount) / self.nTokenEveryBuy)
+	local callback = function(nCount)
+		self.nBuyCount = nCount
+		self:RefreshAddCount()
+	end
+	self._mapNode.goQuantitySelector:Init(callback, 1, self.nMaxBuy)
+end
+function StarTowerTokenBuyConfirmCtrl:RefreshAddCount()
+	local sTokenName, sCoinName = "", ""
+	local mapTokenCfgData = ConfigTable.GetData_Item(AllEnum.CoinItemId.AutoDecisionToken)
+	if mapTokenCfgData ~= nil then
+		self:SetPngSprite(self._mapNode.imgToken, mapTokenCfgData.Icon)
+		sTokenName = mapTokenCfgData.Title
+	end
+	local nHas = PlayerData.StarTowerAutoPlan:GetTokenCount()
+	if self.nCoinId ~= 0 then
+		local mapCoinCfg = ConfigTable.GetData_Item(self.nCoinId)
+		if mapCoinCfg ~= nil then
+			self:SetPngSprite(self._mapNode.imgCoin, mapCoinCfg.Icon)
+			sCoinName = mapCoinCfg.Title
+		end
+	end
+	self.nCost = self.nBuyCount * self.nTokenPrice
+	local nRatio = nHas * 100 / self.nMaxToken
+	if nRatio < 1 and 0 < nRatio then
+		nRatio = 1
+	end
+	local nCurRatio = 0 < self.nMaxToken and math.floor(nRatio) or 0
+	NovaAPI.SetTMPText(self._mapNode.txtBeforeValue, nCurRatio .. "%")
+	local nAfterTemp = (nHas + self.nBuyCount * self.nTokenEveryBuy) * 100 / self.nMaxToken
+	if nAfterTemp < 1 and 0 < nAfterTemp then
+		nAfterTemp = 1
+	end
+	local nAfterRatio = 0 < self.nMaxToken and math.floor(nAfterTemp) or 0
+	NovaAPI.SetTMPText(self._mapNode.txtAfterValue, nAfterRatio .. "%")
+	self._mapNode.goMaxValue.gameObject:SetActive(nHas + self.nBuyCount * self.nTokenEveryBuy >= self.nMaxToken)
+	NovaAPI.SetTMPText(self._mapNode.txtCoinCount, string.format("%sx%s", sCoinName, self.nCost))
+	local nCountTemp = self.nBuyCount * self.nTokenEveryBuy * 100 / self._panel.nMaxToken
+	if nCountTemp < 1 and 0 < nCountTemp then
+		nCountTemp = 1
+	end
+	NovaAPI.SetTMPText(self._mapNode.txtTokenCount, string.format("%sx%s", sTokenName, math.floor(nCountTemp) .. "%"))
+	LayoutRebuilder.ForceRebuildLayoutImmediate(self._mapNode.rtGoValue)
+	LayoutRebuilder.ForceRebuildLayoutImmediate(self._mapNode.rtCountBg)
+end
+function StarTowerTokenBuyConfirmCtrl:Close()
+	self._mapNode.animWindow:Play("t_window_04_t_out")
+end
+function StarTowerTokenBuyConfirmCtrl:OnBtnClick_Close()
+	EventManager.Hit("CloseTokenBuyPanel")
+end
+function StarTowerTokenBuyConfirmCtrl:OnBtnClick_Cancel()
+	EventManager.Hit("CloseTokenBuyPanel")
+end
+function StarTowerTokenBuyConfirmCtrl:OnBtnClick_Confirm()
+	local nHasCoin = PlayerData.Coin:GetCoinCount(self.nCoinId)
+	if nHasCoin < self.nCost then
+		local itemCfg = ConfigTable.GetData_Item(self.nCoinId)
+		local itemCostCfg = ConfigTable.GetData_Item(AllEnum.CoinItemId.STONE)
+		if not itemCfg or not itemCostCfg then
+			return
+		end
+		local sTip = orderedFormat(ConfigTable.GetUIText("Recruit_ExchangeGemZero"), itemCfg.Id, self.nCost - nHasCoin, itemCostCfg.Id)
+		local confirmCallback = function()
+			local nStoneCount = PlayerData.Coin:GetCoinCount(AllEnum.CoinItemId.STONE)
+			nStoneCount = nStoneCount + PlayerData.Item:GetItemCountByID(AllEnum.CoinItemId.FREESTONE)
+			if nStoneCount < self.nCost - nHasCoin then
+				local msg = {
+					nType = AllEnum.MessageBox.Confirm,
+					sContent = orderedFormat(ConfigTable.GetUIText("Recruit_Charge") or "", itemCostCfg.Id),
+					callbackConfirm = function()
+						self._panel:JumpToRecharge()
+					end,
+					bBlur = false
+				}
+				EventManager.Hit(EventId.OpenMessageBox, msg)
+			else
+				PlayerData.Coin:SendGemConvertReqReq(self.nCost - nHasCoin, nil)
+			end
+			EventManager.Hit("ShowTokenTopRes", false)
+		end
+		local cancelCallback = function()
+			EventManager.Hit("ShowTokenTopRes", false)
+		end
+		local msg = {
+			nType = AllEnum.MessageBox.Confirm,
+			sContent = sTip,
+			callbackConfirm = confirmCallback,
+			callbackCancel = cancelCallback,
+			bBlur = false
+		}
+		EventManager.Hit(EventId.OpenMessageBox, msg)
+		EventManager.Hit("ShowTokenTopRes", false)
+		return
+	end
+	local callback = function(bSuccess)
+		if bSuccess then
+			local nCountTemp = self.nBuyCount * self.nTokenEveryBuy * 100 / self._panel.nMaxToken
+			if nCountTemp < 1 and 0 < nCountTemp then
+				nCountTemp = 1
+			end
+			local nRatio = math.floor(nCountTemp)
+			EventManager.Hit(EventId.OpenMessageBox, orderedFormat(ConfigTable.GetUIText("TokenBuy_Success"), nRatio))
+			EventManager.Hit("RefreshTokenItemList")
+			EventManager.Hit("CloseTokenBuyPanel")
+		end
+	end
+	PlayerData.StarTowerAutoPlan:SendTokenBuy(self.nBuyCount, callback)
+end
+return StarTowerTokenBuyConfirmCtrl

lua/game/ui/startowerfastbattle/startowertokenbuyctrl.lua

@@ -0,0 +1,178 @@
+local StarTowerTokenBuyCtrl = class("StarTowerTokenBuyCtrl", BaseCtrl)
+local GamepadUIManager = require("GameCore.Module.GamepadUIManager")
+StarTowerTokenBuyCtrl._mapNodeConfig = {
+	imgBlurredBg = {},
+	safeAreaRoot = {
+		sNodeName = "----SafeAreaRoot----"
+	},
+	TopBar = {
+		sNodeName = "TopBarPanel",
+		sCtrlName = "Game.UI.TopBarEx.TopBarCtrl"
+	},
+	MainRoot = {
+		sNodeName = "---Main---",
+		sCtrlName = "Game.UI.StarTowerFastBattle.StarTowerTokenBuyMainCtrl"
+	},
+	ConfirmRoot = {
+		sNodeName = "---Confirm---",
+		sCtrlName = "Game.UI.StarTowerFastBattle.StarTowerTokenBuyConfirmCtrl"
+	},
+	ItemUseRoot = {
+		sNodeName = "---ItemUse---",
+		sCtrlName = "Game.UI.StarTowerFastBattle.StarTowerTokenBuyItemUseCtrl"
+	},
+	goToken = {},
+	animToken = {sNodeName = "goToken", sComponentName = "Animator"},
+	goResBarAnimRoot = {},
+	animResBar = {
+		sNodeName = "goResBarAnimRoot",
+		sComponentName = "Animator"
+	},
+	txtUpperTokenCount = {sComponentName = "TMP_Text"},
+	imgTokenFiller = {sComponentName = "Image"},
+	btnBg = {
+		sComponentName = "Button",
+		callback = "OnBtnClick_Close"
+	}
+}
+StarTowerTokenBuyCtrl._mapEventConfig = {
+	CloseTokenBuyPanel = "OnEvent_CloseTokenBuyPanel",
+	ChangeTokenBuyPanel = "OnEvent_ChangeTokenBuyPanel",
+	ShowTokenTopRes = "OnEvent_ShowTokenTopResBar",
+	[EventId.IsNewDay] = "OnEvent_NewDay",
+	RefreshTokenItemList = "RefreshTopFiller"
+}
+local nMaxFillerWidth = 290
+function StarTowerTokenBuyCtrl:Awake()
+	self.tbWindowStack = {}
+	if self._panel.nPanelType ~= AllEnum.TokenBuyPanelType.Main then
+		self.nDirectPanelType = self._panel.nPanelType
+	end
+	self._panel.nMaxToken = ConfigTable.GetConfigNumber("TowerVitaEnergyMax")
+end
+function StarTowerTokenBuyCtrl:OnEnable()
+	if PanelManager.CheckPanelOpen(PanelId.StarTowerFastBattle) then
+		local canvas = self.gameObject:GetComponent("Canvas")
+		NovaAPI.SetCanvasSortingOrder(canvas, AllEnum.UI_SORTING_ORDER.StarTowerAutoDecisionTokenBuy)
+	end
+	GamepadUIManager.EnableGamepadUI("StarTowerTokenBuyCtrl", {}, nil, true, false, self._panel._nIndex)
+	self.animRoot = self.gameObject:GetComponent("Animator")
+	self._mapNode.safeAreaRoot.gameObject:SetActive(false)
+	self._mapNode.btnBg.gameObject:SetActive(false)
+	self._mapNode.imgBlurredBg.gameObject:SetActive(true)
+	self._mapNode.goResBarAnimRoot.gameObject:SetActive(false)
+	local wait = function()
+		coroutine.yield(CS.UnityEngine.WaitForEndOfFrame())
+		self._mapNode.safeAreaRoot.gameObject:SetActive(true)
+		self._mapNode.btnBg.gameObject:SetActive(true)
+		table.insert(self.tbWindowStack, self._panel.nPanelType)
+		self:ChangePanelType()
+	end
+	cs_coroutine.start(wait)
+	self:RefreshTopFiller()
+end
+function StarTowerTokenBuyCtrl:RefreshTopFiller()
+	local nCurToken = PlayerData.StarTowerAutoPlan:GetTokenCount()
+	local nRatio = nCurToken / self._panel.nMaxToken
+	if nRatio < 0.01 and 0 < nRatio then
+		nRatio = 0.01
+	end
+	NovaAPI.SetImageFillAmount(self._mapNode.imgTokenFiller, nRatio)
+	local nPercent = math.floor(nCurToken * 100 / self._panel.nMaxToken)
+	if 0 < nCurToken then
+		nPercent = math.max(1, nPercent)
+	end
+	NovaAPI.SetTMPText(self._mapNode.txtUpperTokenCount, nPercent .. "%")
+end
+function StarTowerTokenBuyCtrl:ChangePanelType()
+	self._mapNode.MainRoot.gameObject:SetActive(self._panel.nPanelType == AllEnum.TokenBuyPanelType.Main)
+	self._mapNode.ConfirmRoot.gameObject:SetActive(self._panel.nPanelType == AllEnum.TokenBuyPanelType.BuyConfirm)
+	self._mapNode.ItemUseRoot.gameObject:SetActive(self._panel.nPanelType == AllEnum.TokenBuyPanelType.ItemUse)
+	if self.nDirectPanelType ~= nil then
+		local bShowToken = self.nDirectPanelType == AllEnum.TokenBuyPanelType.BuyConfirm
+		self._mapNode.goToken.gameObject:SetActive(not bShowToken)
+		self._mapNode.goResBarAnimRoot.gameObject:SetActive(bShowToken)
+		local sAnim = bShowToken and "tc_top_bar_02_t_in" or "tc_top_bar_01_t_in"
+		self._mapNode.animResBar:Play(sAnim)
+		self.nDirectPanelType = nil
+	else
+		local bShowRecover = self._panel.nPanelType ~= AllEnum.TokenBuyPanelType.BuyConfirm
+		local sRecoverAnim = bShowRecover and "EnergyBuy_Time_in" or "EnergyBuy_Time_out"
+		local sTokenAnim = bShowRecover and "tc_top_bar_02_t_in" or "tc_top_bar_02_t_out"
+		local sResBarAnim = not bShowRecover and "tc_top_bar_01_t_in" or "tc_top_bar_01_t_out"
+		self._mapNode.goResBarAnimRoot.gameObject:SetActive(not bShowRecover)
+		self._mapNode.goToken.gameObject:SetActive(bShowRecover)
+		self._mapNode.animToken:Play(sTokenAnim)
+		self.animRoot:Play(sRecoverAnim)
+		self._mapNode.animResBar:Play(sResBarAnim)
+	end
+	if self._panel.nPanelType == AllEnum.TokenBuyPanelType.Main then
+		self._mapNode.MainRoot:ShowPanel()
+	elseif self._panel.nPanelType == AllEnum.TokenBuyPanelType.BuyConfirm then
+		self._mapNode.ConfirmRoot:ShowPanel()
+	elseif self._panel.nPanelType == AllEnum.TokenBuyPanelType.ItemUse then
+		self._mapNode.ItemUseRoot:ShowPanel()
+	end
+end
+function StarTowerTokenBuyCtrl:ClosePanel(nPanelType)
+	self._mapNode.animToken:Play("tc_top_bar_02_t_out")
+	self._mapNode.animResBar:Play("tc_top_bar_01_t_out")
+	self.animRoot:Play("EnergyBuy_Time_out")
+	if nPanelType == AllEnum.TokenBuyPanelType.Main then
+		self._mapNode.MainRoot:Close()
+	elseif nPanelType == AllEnum.TokenBuyPanelType.BuyConfirm then
+		self._mapNode.ConfirmRoot:Close()
+	elseif nPanelType == AllEnum.TokenBuyPanelType.ItemUse then
+		self._mapNode.ItemUseRoot:Close()
+	end
+end
+function StarTowerTokenBuyCtrl:OnDisable()
+	GamepadUIManager.DisableGamepadUI("StarTowerTokenBuyCtrl")
+end
+function StarTowerTokenBuyCtrl:OnDestroy()
+end
+function StarTowerTokenBuyCtrl:OnEvent_ChangeTokenBuyPanel(nPanelType)
+	self:ClosePanel(self._panel.nPanelType)
+	self._panel.nPanelType = nPanelType
+	table.insert(self.tbWindowStack, self._panel.nPanelType)
+	self:AddTimer(1, 0.3, function()
+		self:ChangePanelType()
+	end, true, true, true)
+end
+function StarTowerTokenBuyCtrl:OnEvent_CloseTokenBuyPanel(bCloseAll)
+	local nPanelType = table.remove(self.tbWindowStack, #self.tbWindowStack)
+	if nPanelType ~= self._panel.nPanelType or bCloseAll then
+		EventManager.Hit(EventId.ClosePanel, PanelId.StarTowerTokenBuyPanel)
+	else
+		self:ClosePanel(self._panel.nPanelType)
+		self:AddTimer(1, 0.3, function()
+			if #self.tbWindowStack > 0 then
+				self._panel.nPanelType = self.tbWindowStack[#self.tbWindowStack]
+				self:ChangePanelType()
+			else
+				EventManager.Hit(EventId.ClosePanel, PanelId.StarTowerTokenBuyPanel)
+			end
+		end, true, true, true)
+	end
+end
+function StarTowerTokenBuyCtrl:OnBtnClick_Close()
+	self:OnEvent_CloseTokenBuyPanel(true)
+end
+function StarTowerTokenBuyCtrl:OnEvent_ShowTokenTopResBar(bShow)
+	self._mapNode.goResBarAnimRoot.gameObject:SetActive(bShow)
+	self:RefreshTopFiller()
+end
+function StarTowerTokenBuyCtrl:OnEvent_NewDay()
+	if PanelManager.GetCurPanelId() == PanelId.MainView then
+		EventManager.Hit("NewDay_Clear_Guide")
+		local msg = {
+			nType = AllEnum.MessageBox.Alert,
+			sContent = ConfigTable.GetUIText("Alert_NextDay"),
+			callbackConfirm = function()
+				PanelManager.Home()
+			end
+		}
+		EventManager.Hit(EventId.OpenMessageBox, msg)
+	end
+end
+return StarTowerTokenBuyCtrl

lua/game/ui/startowerfastbattle/startowertokenbuyitemctrl.lua

@@ -0,0 +1,86 @@
+local StarTowerTokenBuyItemCtrl = class("StarTowerTokenBuyItemCtrl", BaseCtrl)
+StarTowerTokenBuyItemCtrl._mapNodeConfig = {
+	btnUse = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_Use"
+	},
+	txtBtnUse = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Energy_Buy_Item_Use"
+	},
+	btnUseGray = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_Use"
+	},
+	txtBtnUseGray = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Energy_Buy_Item_Use"
+	},
+	txtPermanent = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Energy_Item_Permanent_Time"
+	},
+	txtHaveCount = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Energy_Item_Count_Text"
+	},
+	txtHaveCountValue = {sComponentName = "TMP_Text"},
+	ctrlItem = {
+		sNodeName = "goEnergyItem",
+		sCtrlName = "Game.UI.TemplateEx.TemplateItemCtrl"
+	},
+	btnItem = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_Item"
+	},
+	txtItemName = {sComponentName = "TMP_Text"},
+	txtTokenValue = {sComponentName = "TMP_Text"},
+	imgToken = {sComponentName = "Image"}
+}
+StarTowerTokenBuyItemCtrl._mapEventConfig = {}
+function StarTowerTokenBuyItemCtrl:SetItem(mapItemData)
+	self.mapItemData = mapItemData
+	NovaAPI.SetTMPText(self._mapNode.txtHaveCountValue, mapItemData.nCount)
+	self._mapNode.btnUseGray.gameObject:SetActive(mapItemData.nCount == 0)
+	self._mapNode.btnUse.gameObject:SetActive(mapItemData.nCount > 0)
+	local itemId = mapItemData.nTid
+	local mapItemCfg = ConfigTable.GetData_Item(itemId)
+	self._mapNode.ctrlItem:SetItem(itemId, nil, nil, nil, nil, nil, nil, true, nil, true)
+	NovaAPI.SetTMPText(self._mapNode.txtItemName, mapItemCfg.Title)
+	local nCountTemp = mapItemData.nTokenValue * 100 / self._panel.nMaxToken
+	if nCountTemp < 1 and 0 < nCountTemp then
+		nCountTemp = 1
+	end
+	local nRatio = math.floor(nCountTemp)
+	NovaAPI.SetTMPText(self._mapNode.txtTokenValue, "+" .. nRatio .. "%")
+end
+function StarTowerTokenBuyItemCtrl:OnBtnClick_Use()
+	if self.mapItemData.nCount == 0 then
+		EventManager.Hit(EventId.OpenMessageBox, {
+			nType = AllEnum.MessageBox.Tips,
+			sContent = ConfigTable.GetUIText("TokenBuy_NoItem"),
+			bBlur = false
+		})
+		return
+	end
+	local nCurToken = PlayerData.StarTowerAutoPlan:GetTokenCount()
+	if nCurToken >= self._panel.nMaxToken then
+		EventManager.Hit(EventId.OpenMessageBox, {
+			nType = AllEnum.MessageBox.Tips,
+			sContent = ConfigTable.GetUIText("TokenBuy_HitLimit"),
+			bBlur = false
+		})
+		return
+	end
+	self._panel.mapItemData = self.mapItemData
+	EventManager.Hit("ChangeTokenBuyPanel", AllEnum.TokenBuyPanelType.ItemUse)
+end
+function StarTowerTokenBuyItemCtrl:OnBtnClick_Item(btn)
+	local mapData = {
+		nTid = self.mapItemData.nTid,
+		bShowDepot = true,
+		bShowJumpto = false
+	}
+	EventManager.Hit(EventId.OpenPanel, PanelId.ItemTips, btn.transform, mapData)
+end
+return StarTowerTokenBuyItemCtrl

lua/game/ui/startowerfastbattle/startowertokenbuyitemusectrl.lua

@@ -0,0 +1,207 @@
+local StarTowerTokenBuyItemUseCtrl = class("StarTowerTokenBuyItemUseCtrl", BaseCtrl)
+local LayoutRebuilder = CS.UnityEngine.UI.LayoutRebuilder
+StarTowerTokenBuyItemUseCtrl._mapNodeConfig = {
+	goWindow = {},
+	animWindow = {sNodeName = "goWindow", sComponentName = "Animator"},
+	txtWindowTitle = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Energy_Item_Use_Title"
+	},
+	btnClose = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_Close"
+	},
+	btnItem = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_Item"
+	},
+	ctrlItem = {
+		sNodeName = "goItem",
+		sCtrlName = "Game.UI.TemplateEx.TemplateItemCtrl"
+	},
+	txtItemName = {sComponentName = "TMP_Text"},
+	txtItemDesc = {sComponentName = "TMP_Text"},
+	txtHaveCount = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Energy_Item_Count_Text"
+	},
+	txtHaveCountValue = {sComponentName = "TMP_Text"},
+	txtAddValue = {sComponentName = "TMP_Text"},
+	txtPermanent = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Energy_Item_Permanent_Time"
+	},
+	txtStock = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Energy_Item_Use_Count"
+	},
+	goQuantitySelector = {
+		sNodeName = "tc_quantity_selector",
+		sCtrlName = "Game.UI.TemplateEx.TemplateQuantitySelectorCtrl"
+	},
+	txtHave = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "TokenBuy_Confirm_Text"
+	},
+	imgArrow = {},
+	txtBeforeValue = {sComponentName = "TMP_Text"},
+	txtAfterValue = {sComponentName = "TMP_Text"},
+	goMaxValue = {},
+	txtMaxValue = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Energy_Count_Max"
+	},
+	rtCountBg = {
+		sNodeName = "imgCountBg",
+		sComponentName = "RectTransform"
+	},
+	btnConfirm2 = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_Confirm"
+	},
+	txtConfirmBtn = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Energy_Item_Use_Btn_Text"
+	}
+}
+StarTowerTokenBuyItemUseCtrl._mapEventConfig = {}
+function StarTowerTokenBuyItemUseCtrl:Awake()
+end
+function StarTowerTokenBuyItemUseCtrl:OnEnable()
+end
+function StarTowerTokenBuyItemUseCtrl:ShowPanel()
+	self.mapItemData = self._panel.mapItemData
+	self.bBlur = self._panel.bBlur
+	self.nUseCount = 1
+	self.nMaxCount = 0
+	self.nMinCount = 0
+	self._mapNode.animWindow:Play("t_window_04_t_in")
+	EventManager.Hit(EventId.TemporaryBlockInput, 0.3)
+	self:RefreshItem()
+	local callback = function(nCount)
+		self.nUseCount = nCount
+		self:RefreshAddCount()
+	end
+	self._mapNode.goQuantitySelector:Init(callback, self.nUseCount, self.nUseCountLimit)
+	self:RefreshAddCount()
+end
+function StarTowerTokenBuyItemUseCtrl:OnDisable()
+end
+function StarTowerTokenBuyItemUseCtrl:OnDestroy()
+end
+function StarTowerTokenBuyItemUseCtrl:RefreshItem()
+	local itemId = self.mapItemData.nTid
+	self._mapNode.ctrlItem:SetItem(itemId, nil, nil, nil, nil, nil, nil, true, nil, true)
+	local mapItemCfg = ConfigTable.GetData_Item(itemId)
+	if mapItemCfg then
+		NovaAPI.SetTMPText(self._mapNode.txtItemName, mapItemCfg.Title)
+		NovaAPI.SetTMPText(self._mapNode.txtItemDesc, mapItemCfg.Desc)
+	end
+	NovaAPI.SetTMPText(self._mapNode.txtHaveCountValue, self.mapItemData.nCount)
+	self.nMaxCount = self.mapItemData.nCount
+	local nCountTemp = self.mapItemData.nTokenValue * 100 / self._panel.nMaxToken
+	if nCountTemp < 1 and 0 < nCountTemp then
+		nCountTemp = 1
+	end
+	local nRatio = math.floor(nCountTemp)
+	NovaAPI.SetTMPText(self._mapNode.txtAddValue, string.format("+%s", nRatio .. "%"))
+	self.nUseCountLimit = 0
+	local nCurToken = PlayerData.StarTowerAutoPlan:GetTokenCount()
+	for i = 1, self.nMaxCount do
+		nCurToken = nCurToken + self.mapItemData.nTokenValue
+		self.nUseCountLimit = i
+		if nCurToken >= self._panel.nMaxToken then
+			break
+		end
+	end
+end
+function StarTowerTokenBuyItemUseCtrl:RefreshAddCount()
+	local nCurToken = PlayerData.StarTowerAutoPlan:GetTokenCount()
+	local nCountTemp = nCurToken * 100 / self._panel.nMaxToken
+	if nCountTemp < 1 and 0 < nCountTemp then
+		nCountTemp = 1
+	end
+	local nRatio = math.floor(nCountTemp)
+	NovaAPI.SetTMPText(self._mapNode.txtBeforeValue, nRatio .. "%")
+	local nAfterValue = nCurToken + self.mapItemData.nTokenValue * self.nUseCount
+	nCountTemp = nAfterValue * 100 / self._panel.nMaxToken
+	if nCountTemp < 1 and 0 < nCountTemp then
+		nCountTemp = 1
+	end
+	nRatio = math.floor(nCountTemp)
+	NovaAPI.SetTMPText(self._mapNode.txtAfterValue, nRatio .. "%")
+	self._mapNode.imgArrow.gameObject:SetActive(0 < self.nUseCount)
+	self._mapNode.txtAfterValue.gameObject:SetActive(0 < self.nUseCount)
+	self._mapNode.goMaxValue.gameObject:SetActive(nAfterValue >= self._panel.nMaxToken)
+	LayoutRebuilder.ForceRebuildLayoutImmediate(self._mapNode.rtCountBg)
+end
+function StarTowerTokenBuyItemUseCtrl:Close()
+	self._mapNode.animWindow:Play("t_window_04_t_out")
+	EventManager.Hit("ConsumableUsed")
+end
+function StarTowerTokenBuyItemUseCtrl:OnBtnClick_Close()
+	EventManager.Hit("CloseTokenBuyPanel")
+end
+function StarTowerTokenBuyItemUseCtrl:OnBtnClick_Confirm()
+	if self.nUseCount <= 0 then
+		return
+	end
+	local itemList = {}
+	local nUseCount = 0
+	for id, count in pairs(self.mapItemData.mapId) do
+		if nUseCount < self.nUseCount then
+			local tbItem = {}
+			tbItem.Tid = self.mapItemData.nTid
+			tbItem.Id = id
+			if nUseCount + count > self.nUseCount then
+				tbItem.Qty = self.nUseCount - nUseCount
+			else
+				tbItem.Qty = count
+			end
+			table.insert(itemList, tbItem)
+		else
+			break
+		end
+		nUseCount = nUseCount + count
+	end
+	local nMaxCount = 0
+	local nCurToken = PlayerData.StarTowerAutoPlan:GetTokenCount()
+	for i = 1, self.nUseCount do
+		nMaxCount = i
+		nCurToken = nCurToken + self.mapItemData.nTokenValue
+		if nCurToken >= self._panel.nMaxToken then
+			break
+		end
+	end
+	if nMaxCount < self.nUseCount then
+		local sTip = ConfigTable.GetUIText("Energy_Use_Tip_2")
+		EventManager.Hit(EventId.OpenMessageBox, {
+			nType = AllEnum.MessageBox.Tips,
+			sContent = sTip,
+			bBlur = false
+		})
+		return
+	end
+	if nil ~= next(itemList) then
+		local msgCallback = function()
+			local nCountTemp = self.mapItemData.nTokenValue * self.nUseCount * 100 / self._panel.nMaxToken
+			if nCountTemp < 1 and 0 < nCountTemp then
+				nCountTemp = 1
+			end
+			local nRatio = math.floor(nCountTemp)
+			EventManager.Hit(EventId.OpenMessageBox, orderedFormat(ConfigTable.GetUIText("TokenBuy_Success"), nRatio))
+			EventManager.Hit("CloseTokenBuyPanel")
+			EventManager.Hit("RefreshTokenItemList")
+		end
+		PlayerData.Item:SendUseItemMsg(itemList, msgCallback)
+	end
+end
+function StarTowerTokenBuyItemUseCtrl:OnBtnClick_Item(btn)
+	local mapData = {
+		nTid = self.mapItemData.nTid,
+		bShowDepot = true,
+		bShowJumpto = false
+	}
+	EventManager.Hit(EventId.OpenPanel, PanelId.ItemTips, btn.transform, mapData)
+end
+return StarTowerTokenBuyItemUseCtrl

lua/game/ui/startowerfastbattle/startowertokenbuymainctrl.lua

@@ -0,0 +1,236 @@
+local StarTowerTokenBuyMainCtrl = class("StarTowerTokenBuyMainCtrl", BaseCtrl)
+local LayoutRebuilder = CS.UnityEngine.UI.LayoutRebuilder
+local tbResidentTokenItemId = {81011}
+local GetTokenValue = function(nItemId)
+	local mapItemCfg = ConfigTable.GetData_Item(nItemId)
+	if mapItemCfg == nil then
+		return 0
+	end
+	local mapUseCfg = decodeJson(mapItemCfg.UseArgs) or {}
+	local nTokenValue = mapUseCfg[tostring(AllEnum.CoinItemId.AutoDecisionToken)] or mapUseCfg[AllEnum.CoinItemId.AutoDecisionToken]
+	return tonumber(nTokenValue) or 0
+end
+local GetItemInstances = function(mapItemData)
+	local mapId = {}
+	local nTotalCount = 0
+	for _, mapInstanceGroup in pairs(mapItemData.mapExpires or {}) do
+		for nInstanceId, nCount in pairs(mapInstanceGroup.mapId or {}) do
+			mapId[nInstanceId] = (mapId[nInstanceId] or 0) + nCount
+			nTotalCount = nTotalCount + nCount
+		end
+	end
+	return mapId, nTotalCount
+end
+StarTowerTokenBuyMainCtrl._mapNodeConfig = {
+	goWindow = {},
+	animWindow = {sNodeName = "goWindow", sComponentName = "Animator"},
+	txtWindowTitle = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "TokenBuy_WindowTitle"
+	},
+	btnClose = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_Close"
+	},
+	goBuyItem = {},
+	txtBuyName = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "TokenBuy_Desc"
+	},
+	imgEnergyBg = {},
+	txtBuyCount = {sComponentName = "TMP_Text"},
+	btnBuy = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_Buy"
+	},
+	btnBuyGray = {
+		sComponentName = "UIButton",
+		callback = "OnBtnClick_BuyGray"
+	},
+	txtBuyButton = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Energy_Item_Use_Btn_Text"
+	},
+	txtBuyButtonGray = {
+		sComponentName = "TMP_Text",
+		sLanguageId = "Energy_Item_Use_Btn_Text"
+	},
+	imgBuyCoin = {sComponentName = "Image"},
+	txtBuyCost = {sComponentName = "TMP_Text"},
+	goItemContent = {sComponentName = "Transform"},
+	rtItemContent = {
+		sNodeName = "goItemContent",
+		sComponentName = "RectTransform"
+	},
+	goItem = {},
+	goItemList = {
+		sComponentName = "RectTransform"
+	}
+}
+StarTowerTokenBuyMainCtrl._mapEventConfig = {
+	RefreshTokenItemList = "RefreshTokenItem"
+}
+function StarTowerTokenBuyMainCtrl:Awake()
+end
+function StarTowerTokenBuyMainCtrl:OnEnable()
+	self.tbItemCtrl = {}
+end
+function StarTowerTokenBuyMainCtrl:OnDisable()
+	for _, v in ipairs(self.tbItemCtrl) do
+		local obj = v.gameObject
+		self:UnbindCtrlByNode(v)
+		destroy(obj)
+	end
+	self.tbItemCtrl = {}
+end
+function StarTowerTokenBuyMainCtrl:OnDestroy()
+end
+function StarTowerTokenBuyMainCtrl:ShowPanel()
+	self._mapNode.goItem.gameObject:SetActive(false)
+	self._mapNode.animWindow:Play("t_window_04_t_in")
+	EventManager.Hit(EventId.TemporaryBlockInput, 0.3)
+	self:RefreshTokenItem()
+	local mapVitaTokenPrice = ConfigTable.GetConfigArray("TowerVitaEnergyPurchasedPrice")
+	self.nTokenPrice = tonumber(mapVitaTokenPrice[2])
+	self.nCoinId = tonumber(mapVitaTokenPrice[1])
+	local nRecoverValue = ConfigTable.GetConfigNumber("TowerVitaEnergyPurchasedValue")
+	local nCountTemp = nRecoverValue * 100 / self._panel.nMaxToken
+	if nCountTemp < 1 and 0 < nCountTemp then
+		nCountTemp = 1
+	end
+	local nRecoverRatio = math.floor(nCountTemp)
+	self:SetSprite_Coin(self._mapNode.imgBuyCoin, self.nCoinId)
+	NovaAPI.SetTMPText(self._mapNode.txtBuyCost, self.nTokenPrice)
+	NovaAPI.SetTMPText(self._mapNode.txtBuyCount, "+" .. nRecoverRatio .. "%")
+	local hasCount = PlayerData.Coin:GetCoinCount(self.nCoinId)
+	NovaAPI.SetTMPColor(self._mapNode.txtBuyCost, hasCount < self.nTokenPrice and Red_Unable or Blue_Normal)
+	self._mapNode.btnBuy.gameObject:SetActive(true)
+	self._mapNode.btnBuyGray.gameObject:SetActive(false)
+end
+function StarTowerTokenBuyMainCtrl:RefreshTokenItem()
+	self.tbItems = {}
+	local tbItems = PlayerData.Item:GetItemsByStype(GameEnum.itemStype.TokenItem)
+	local mapResidentItem = {}
+	for _, nItemId in ipairs(tbResidentTokenItemId) do
+		mapResidentItem[nItemId] = false
+	end
+	for _, mapItemData in ipairs(tbItems) do
+		local nTokenValue = GetTokenValue(mapItemData.Tid)
+		if 0 < nTokenValue then
+			local mapId, nCount = GetItemInstances(mapItemData)
+			if 0 < nCount then
+				table.insert(self.tbItems, {
+					nTid = mapItemData.Tid,
+					mapId = mapId,
+					nTokenValue = nTokenValue,
+					nCount = nCount,
+					nSort = 0
+				})
+				if mapResidentItem[mapItemData.Tid] ~= nil then
+					mapResidentItem[mapItemData.Tid] = true
+				end
+			end
+		end
+	end
+	for _, nItemId in ipairs(tbResidentTokenItemId) do
+		if mapResidentItem[nItemId] == false and ConfigTable.GetData_Item(nItemId) ~= nil then
+			table.insert(self.tbItems, {
+				nTid = nItemId,
+				mapId = {},
+				nCount = 0,
+				nTokenValue = GetTokenValue(nItemId),
+				nSort = -1
+			})
+		end
+	end
+	table.sort(self.tbItems, function(a, b)
+		if a.nSort == b.nSort then
+			return a.nTid < b.nTid
+		end
+		return a.nSort > b.nSort
+	end)
+	for _, v in ipairs(self.tbItemCtrl) do
+		v.gameObject:SetActive(false)
+	end
+	for k, v in ipairs(self.tbItems) do
+		if nil == self.tbItemCtrl[k] then
+			local obj = instantiate(self._mapNode.goItem, self._mapNode.goItemList)
+			obj.gameObject:SetActive(true)
+			local objCtrl = self:BindCtrlByNode(obj, "Game.UI.StarTowerFastBattle.StarTowerTokenBuyItemCtrl")
+			objCtrl:SetItem(v)
+			self.tbItemCtrl[k] = objCtrl
+		else
+			self.tbItemCtrl[k].gameObject:SetActive(true)
+			self.tbItemCtrl[k]:SetItem(v)
+		end
+	end
+	LayoutRebuilder.ForceRebuildLayoutImmediate(self._mapNode.rtItemContent)
+end
+function StarTowerTokenBuyMainCtrl:Close()
+	self._mapNode.animWindow:Play("t_window_04_t_out")
+	EventManager.Hit(EventId.TemporaryBlockInput, 0.3)
+end
+function StarTowerTokenBuyMainCtrl:OnBtnClick_Close()
+	EventManager.Hit("CloseTokenBuyPanel")
+end
+function StarTowerTokenBuyMainCtrl:OnBtnClick_Buy()
+	local nHasCoin = PlayerData.Coin:GetCoinCount(self.nCoinId)
+	if nHasCoin < self.nTokenPrice then
+		local itemCfg = ConfigTable.GetData_Item(self.nCoinId)
+		local itemCostCfg = ConfigTable.GetData_Item(AllEnum.CoinItemId.STONE)
+		if not itemCfg or not itemCostCfg then
+			return
+		end
+		local sTip = orderedFormat(ConfigTable.GetUIText("Recruit_ExchangeGemZero"), itemCfg.Id, self.nTokenPrice - nHasCoin, itemCostCfg.Id)
+		local confirmCallback = function()
+			local nStoneCount = PlayerData.Coin:GetCoinCount(AllEnum.CoinItemId.STONE)
+			nStoneCount = nStoneCount + PlayerData.Item:GetItemCountByID(AllEnum.CoinItemId.FREESTONE)
+			if nStoneCount < self.nTokenPrice - nHasCoin then
+				local msg = {
+					nType = AllEnum.MessageBox.Confirm,
+					sContent = orderedFormat(ConfigTable.GetUIText("Recruit_Charge") or "", itemCostCfg.Id),
+					callbackConfirm = function()
+						self._panel:JumpToRecharge()
+					end,
+					bBlur = false
+				}
+				EventManager.Hit(EventId.OpenMessageBox, msg)
+			else
+				PlayerData.Coin:SendGemConvertReqReq(self.nTokenPrice - nHasCoin, nil)
+			end
+			EventManager.Hit("ShowTokenTopRes", false)
+		end
+		local cancelCallback = function()
+			EventManager.Hit("ShowTokenTopRes", false)
+		end
+		local msg = {
+			nType = AllEnum.MessageBox.Confirm,
+			sContent = sTip,
+			callbackConfirm = confirmCallback,
+			callbackCancel = cancelCallback,
+			bBlur = false
+		}
+		EventManager.Hit(EventId.OpenMessageBox, msg)
+		EventManager.Hit("ShowTokenTopRes", false)
+		return
+	end
+	local nCurToken = PlayerData.StarTowerAutoPlan:GetTokenCount()
+	if nCurToken >= self._panel.nMaxToken then
+		local sTip = ConfigTable.GetUIText("TokenBuy_HitLimit")
+		EventManager.Hit(EventId.OpenMessageBox, {
+			nType = AllEnum.MessageBox.Tips,
+			sContent = sTip
+		})
+		return
+	end
+	EventManager.Hit("ChangeTokenBuyPanel", AllEnum.TokenBuyPanelType.BuyConfirm)
+end
+function StarTowerTokenBuyMainCtrl:OnBtnClick_BuyGray()
+	local sTip = ConfigTable.GetUIText("TokenBuy_NoCoin")
+	EventManager.Hit(EventId.OpenMessageBox, {
+		nType = AllEnum.MessageBox.Tips,
+		bPositive = true,
+		sContent = sTip
+	})
+end
+return StarTowerTokenBuyMainCtrl

lua/game/ui/startowerfastbattle/startowertokenbuypanel.lua

@@ -0,0 +1,35 @@
+local StarTowerTokenBuyPanel = class("StarTowerTokenBuyPanel", BasePanel)
+StarTowerTokenBuyPanel._bIsMainPanel = false
+StarTowerTokenBuyPanel._tbDefine = {
+	{
+		sPrefabPath = "StarTowerFastBattle/StarTowerTokenBuyPanel.prefab",
+		sCtrlName = "Game.UI.StarTowerFastBattle.StarTowerTokenBuyCtrl"
+	}
+}
+function StarTowerTokenBuyPanel:Awake()
+	self.nPanelType = self._tbParam[1] or AllEnum.TokenBuyPanelType.Main
+	self.mapItemData = self._tbParam[2]
+	self.bBlur = self._tbParam[3]
+	self.nMaxToken = ConfigTable.GetConfigNumber("TowerVitaEnergyMax")
+	self.callback = self._tbParam[4]
+end
+function StarTowerTokenBuyPanel:JumpToRecharge()
+	if ConfigTable.GetConfigNumber("IsShowComBtn") ~= 1 then
+		EventManager.Hit(EventId.OpenMessageBox, ConfigTable.GetUIText("Function_NotAvailable"))
+		return
+	end
+	if self.callback ~= nil then
+		self.callback()
+	end
+	EventManager.Hit(EventId.ClosePanel, PanelId.StarTowerTokenBuyPanel)
+	EventManager.Hit(EventId.ClosePanel, PanelId.StarTowerAutoDecisionSettingPanel)
+	local func_OpenRecharge = function()
+		EventManager.Hit(EventId.OpenPanel, PanelId.Mall, AllEnum.MallToggle.Gem)
+	end
+	if PanelManager.GetCurPanelId() == PanelId.StarTowerFastBattle then
+		EventManager.Hit("StarTowerFastBattleLeaveForRecharge", func_OpenRecharge)
+	else
+		func_OpenRecharge()
+	end
+end
+return StarTowerTokenBuyPanel