local PenguinLevel = class("PenguinLevel")
local PenguinCard = require("Game.UI.Play_PenguinCard.PenguinCard")
local PenguinCardBuff = require("Game.UI.Play_PenguinCard.PenguinCardBuff")
local PenguinCardQuest = require("Game.UI.Play_PenguinCard.PenguinCardQuest")
local TimerManager = require("GameCore.Timer.TimerManager")
local LocalData = require("GameCore.Data.LocalData")
local ConfigData = require("GameCore.Data.ConfigData")
local PenguinCardUtils = require("Game.UI.Play_PenguinCard.PenguinCardUtils")
function PenguinLevel:Init(nFloorId, nLevelId, nActId, tbStarScore)
	self.nFloorId = nFloorId
	self.tbStarScore = tbStarScore or {
		0,
		0,
		0
	}
	self.nLevelId = nLevelId
	self.nActId = nActId
	self:ParseConfigData()
	self:ParseLocalData()
	EventManager.Hit(EventId.OpenPanel, PanelId.PenguinCard, self)
end
function PenguinLevel:ParseConfigData()
	self.nBaseCardCount = ConfigTable.GetConfigNumber("PenguinCardHandCardCount")
	self.nMaxRound = ConfigTable.GetConfigNumber("PenguinCardMaxRound")
	self.nMaxSlot = ConfigTable.GetConfigNumber("PenguinCardMaxSlot")
	self.nMaxBuyLimit = ConfigTable.GetConfigNumber("PenguinCardHandCardCount")
	self.tbRoundUpgradeCost = ConfigTable.GetConfigNumberArray("PenguinCardRoundUpgradeCost")
	self.tbSlotUpgradeCost = ConfigTable.GetConfigNumberArray("PenguinCardSlotUpgradeCost")
	self.tbBuyLimitUpgradeCost = ConfigTable.GetConfigNumberArray("PenguinCardBuyLimitUpgradeCost")
	self.nFireScore = ConfigTable.GetConfigNumber("PenguinCardFeverScore")
	self.nPenguinCardRollCount = ConfigTable.GetConfigNumber("PenguinCardRollCount")
	self.mapBuyCost = {}
	local func_ForEach_Line = function(mapData)
		self.mapBuyCost[mapData.Count] = {
			Turn = mapData.Turn,
			Cost = mapData.Cost
		}
	end
	ForEachTableLine(DataTable.PenguinCardCost, func_ForEach_Line)
	self.mapHandRankRule = {}
	local func_ForEach_Rank = function(mapData)
		self.mapHandRankRule[mapData.Order] = {
			Id = mapData.Id,
			SuitCount = mapData.SuitCount,
			Value = mapData.Value,
			Ratio = mapData.Ratio * ConfigData.IntFloatPrecision
		}
	end
	ForEachTableLine(DataTable.PenguinCardHandRank, func_ForEach_Rank)
	self.mapTendencyScore = {}
	local func_ForEach_Tendency = function(mapData)
		if not self.mapTendencyScore[mapData.GroupId] then
			self.mapTendencyScore[mapData.GroupId] = {}
		end
		table.insert(self.mapTendencyScore[mapData.GroupId], mapData.Score)
	end
	ForEachTableLine(DataTable.PenguinCardTendency, func_ForEach_Tendency)
	for _, v in pairs(self.mapTendencyScore) do
		table.sort(v)
	end
end
function PenguinLevel:ParseLocalData()
	local bAuto = LocalData.GetPlayerLocalData("PenguinCardAuto")
	self.bAuto = bAuto == true
	local nSpeed = LocalData.GetPlayerLocalData("PenguinCardSpeed")
	self.nSpeed = nSpeed or 1
end
function PenguinLevel:ParseLevelData(nFloorId)
	local mapLevelCfg = ConfigTable.GetData("PenguinCardFloor", nFloorId)
	if not mapLevelCfg then
		return
	end
	self.nMaxTurn = mapLevelCfg.MaxTurn
	self.nScore = mapLevelCfg.InitialScore
	self.nTotalScore = mapLevelCfg.InitialScore
	self.nSlotCount = mapLevelCfg.InitialSlot
	self.nRoundLimit = mapLevelCfg.InitialRound
	self.nFixedTurnGroupId = mapLevelCfg.FixedTurn
	self.sLevelDesc = mapLevelCfg.Floortips
	self.bShowWin = mapLevelCfg.ShowWin
	self.nQuestTurn = mapLevelCfg.QuestTurn
	self.nQuestGroup = mapLevelCfg.QuestGroup
	self.nBuyLimit = mapLevelCfg.InitialBuyLimit
	self.nWeightGroupId = mapLevelCfg.WeightGroup
	local mapPoolCfg = ConfigTable.GetData("PenguinBaseCardPool", mapLevelCfg.PoolId)
	if not mapPoolCfg then
		return
	end
	self.mapBaseCardPool = {
		tbId = mapPoolCfg.BaseCardId,
		tbWeight = mapPoolCfg.Weight
	}
end
function PenguinLevel:ClearLevelData()
	self.nGameState = nil
	self.nCurTurn = 0
	self.nCurRound = 0
	self.nHp = 3
	if self.tbBuffPool == nil then
		self.tbBuffPool = {}
	end
	if self.tbBuff == nil then
		self.tbBuff = {}
	elseif next(self.tbBuff) ~= nil then
		local nCount = #self.tbBuff
		for i = nCount, 1, -1 do
			self:RecycleBuff(self.tbBuff[i])
			table.remove(self.tbBuff, i)
		end
	end
	if self.tbPenguinCardPool == nil then
		self.tbPenguinCardPool = {}
	end
	if self.tbPenguinCard == nil then
		self.tbPenguinCard = {}
		for i = 1, 6 do
			self.tbPenguinCard[i] = 0
		end
	elseif next(self.tbPenguinCard) ~= nil then
		for i = 1, 6 do
			local mapCard = self.tbPenguinCard[i]
			if mapCard ~= 0 then
				self:RecyclePenguinCard(mapCard)
				self.tbPenguinCard[i] = 0
			end
		end
	end
	if self.tbQuestPool == nil then
		self.tbQuestPool = {}
	end
	self.mapQuest = nil
	self.mapLog = {}
	self.nTotalRound = 0
	self.nBestTurnScore = 0
	self.nBestRoundScore = 0
	self.mapHandRankHistory = {}
	self.mapSuitHistory = {}
	self.nGetPenguinCardCount = 0
end
function PenguinLevel:StartGame()
	math.randomseed(os.time())
	self:ClearLevelData()
	self:ParseLevelData(self.nFloorId)
	self:SwitchGameState()
end
function PenguinLevel:CompleteGame()
	local nNextState = PenguinCardUtils.GameState.Complete
	self:SwitchNextGameState(nNextState, {bManual = true})
end
function PenguinLevel:RestartGame()
	local nNextState = PenguinCardUtils.GameState.Start
	local nWaitTime = self:QuitGameState(nNextState)
	if nWaitTime == 0 then
		self:StartGame()
	else
		TimerManager.Add(1, nWaitTime, self, function()
			self:StartGame()
		end, true, true, true)
		EventManager.Hit(EventId.TemporaryBlockInput, nWaitTime)
	end
end
function PenguinLevel:QuitGame(callback)
	local bAct = false
	if self.nActId then
		local actData = PlayerData.Activity:GetActivityDataById(self.nActId)
		if actData then
			local bOpen = actData:CheckActivityOpen()
			if bOpen then
				bAct = true
				local nScore = math.floor(self.nScore)
				actData:SendActivityPenguinCardSettleReq(self.nLevelId, self.nStar, nScore, callback)
			else
				EventManager.Hit(EventId.OpenMessageBox, {
					nType = AllEnum.MessageBox.Alert,
					sContent = ConfigTable.GetUIText("Activity_Invalid_Tip_3")
				})
			end
		end
	end
	if not bAct then
		callback(true)
	end
	self:QuitGameState()
	self:ClearLevelData()
end
function PenguinLevel:SwitchGameState()
	local nNextState = self:CheckNextGameState()
	self:SwitchNextGameState(nNextState)
end
function PenguinLevel:RunGameState(mapParam)
	if self.nGameState == PenguinCardUtils.GameState.Start then
		self:RunState_Start()
	elseif self.nGameState == PenguinCardUtils.GameState.Prepare then
		self:RunState_Prepare()
	elseif self.nGameState == PenguinCardUtils.GameState.Dealing then
		self:RunState_Dealing()
	elseif self.nGameState == PenguinCardUtils.GameState.Flip then
		self:RunState_Flip()
	elseif self.nGameState == PenguinCardUtils.GameState.Settlement then
		self:RunState_Settlement()
	elseif self.nGameState == PenguinCardUtils.GameState.Complete then
		self:RunState_Complete(mapParam)
	elseif self.nGameState == PenguinCardUtils.GameState.Quest then
		self:RunState_Quest()
	end
end
function PenguinLevel:QuitGameState(nNextState)
	local nWaitTime = 0
	if self.nGameState == PenguinCardUtils.GameState.Start then
		nWaitTime = self:QuitState_Start()
	elseif self.nGameState == PenguinCardUtils.GameState.Prepare then
		nWaitTime = self:QuitState_Prepare(nNextState)
	elseif self.nGameState == PenguinCardUtils.GameState.Dealing then
		nWaitTime = self:QuitState_Dealing(nNextState)
	elseif self.nGameState == PenguinCardUtils.GameState.Flip then
		nWaitTime = self:QuitState_Flip(nNextState)
	elseif self.nGameState == PenguinCardUtils.GameState.Settlement then
		nWaitTime = self:QuitState_Settlement(nNextState)
	elseif self.nGameState == PenguinCardUtils.GameState.Complete then
		nWaitTime = self:QuitState_Complete()
	elseif self.nGameState == PenguinCardUtils.GameState.Quest then
		nWaitTime = self:QuitState_Quest(nNextState)
	end
	return nWaitTime
end
function PenguinLevel:CheckNextGameState()
	if self.nGameState == nil then
		return PenguinCardUtils.GameState.Start
	elseif self.nGameState == PenguinCardUtils.GameState.Start then
		if self.nQuestTurn >= 0 and self.nCurTurn >= self.nQuestTurn then
			return PenguinCardUtils.GameState.Quest
		else
			return PenguinCardUtils.GameState.Prepare
		end
	elseif self.nGameState == PenguinCardUtils.GameState.Prepare then
		return PenguinCardUtils.GameState.Dealing
	elseif self.nGameState == PenguinCardUtils.GameState.Dealing then
		return PenguinCardUtils.GameState.Flip
	elseif self.nGameState == PenguinCardUtils.GameState.Flip then
		return PenguinCardUtils.GameState.Settlement
	elseif self.nGameState == PenguinCardUtils.GameState.Settlement then
		if self.nCurRound < self:GetRoundLimitInTurn() then
			return PenguinCardUtils.GameState.Dealing
		end
		if self.nCurTurn >= self.nMaxTurn then
			return PenguinCardUtils.GameState.Complete
		end
		if self.mapQuest ~= nil then
			return PenguinCardUtils.GameState.Quest
		elseif self.nQuestTurn >= 0 and self.nCurTurn >= self.nQuestTurn then
			return PenguinCardUtils.GameState.Quest
		else
			return PenguinCardUtils.GameState.Prepare
		end
	elseif self.nGameState == PenguinCardUtils.GameState.Quest then
		if self.nCurTurn >= self.nMaxTurn or 0 >= self.nHp then
			return PenguinCardUtils.GameState.Complete
		else
			return PenguinCardUtils.GameState.Prepare
		end
	end
end
function PenguinLevel:SwitchNextGameState(nNextState, mapParam)
	local nWaitTime = self:QuitGameState(nNextState)
	if nWaitTime == 0 then
		self.nGameState = nNextState
		self:RunGameState(mapParam)
	else
		TimerManager.Add(1, nWaitTime, self, function()
			self.nGameState = nNextState
			self:RunGameState(mapParam)
		end, true, true, true)
		EventManager.Hit(EventId.TemporaryBlockInput, nWaitTime)
	end
end
function PenguinLevel:RunState_Start()
	EventManager.Hit("PenguinCard_RunState_Start")
end
function PenguinLevel:QuitState_Start()
	EventManager.Hit("PenguinCard_QuitState_Start")
	local nWaitTime = 0.167
	return nWaitTime
end
function PenguinLevel:RunState_Quest()
	self.tbSelectableQuest = {}
	self.bSkipQuestShow = false
	self.mapQuestForShow = nil
	if self.mapQuest ~= nil then
		self.mapQuestForShow = clone(self.mapQuest)
		local bComplete = self.mapQuest:CheckComplete()
		if bComplete then
			self:CompleteQuest()
			self:RollQuest()
		else
			local bExpired = self.mapQuest:CheckExpired()
			if bExpired then
				self:ChangeHp(-1)
				if self.nHp > 0 then
					self:RollQuest()
				end
			else
				self.bSkipQuestShow = true
			end
		end
	else
		self:RollQuest()
		if next(self.tbSelectableQuest) == nil then
			self.bSkipQuestShow = true
		end
	end
	EventManager.Hit("PenguinCard_RunState_Quest", self.bSkipQuestShow)
	if self.bSkipQuestShow then
		self:SwitchGameState()
	end
end
function PenguinLevel:QuitState_Quest(nNextState)
	self.tbSelectableQuest = {}
	self.bSkipQuestShow = false
	self.mapQuestForShow = nil
	EventManager.Hit("PenguinCard_QuitState_Quest", nNextState)
	local nWaitTime = 0
	if nNextState == PenguinCardUtils.GameState.Start then
		nWaitTime = 0.6
	elseif nNextState == PenguinCardUtils.GameState.Prepare then
		nWaitTime = 0.57
	elseif nNextState == PenguinCardUtils.GameState.Complete then
		nWaitTime = 0.6
	end
	return nWaitTime
end
function PenguinLevel:RollQuest()
	local tbId = self:GetRollQuestResult()
	self:ClearSelectableQuest()
	for _, nId in ipairs(tbId) do
		local mapCard = self:CreateQuest(nId)
		table.insert(self.tbSelectableQuest, mapCard)
	end
	self.mapQuest = nil
end
function PenguinLevel:GetRollQuestResult()
	local mapWeightCfg = ConfigTable.GetData("PenguinCardQuestWeight", self.nQuestGroup * 100 + self.nCurTurn)
	if not mapWeightCfg then
		EventManager.Hit(EventId.OpenMessageBox, {
			nType = AllEnum.MessageBox.Tips,
			sSound = "Mode_Card_refresh_falied",
			sContent = ConfigTable.GetUIText("PenguinCard_Error_EmptyQuest")
		})
		return {}
	end
	local tbId = PenguinCardUtils.WeightedRandom(mapWeightCfg.QuestList, mapWeightCfg.Weight, 3)
	return tbId
end
function PenguinLevel:ClearSelectableQuest()
	if next(self.tbSelectableQuest) ~= nil then
		for i = #self.tbSelectableQuest, 1, -1 do
			local mapCard = table.remove(self.tbSelectableQuest, i)
			self:RecycleQuest(mapCard)
		end
	end
end
function PenguinLevel:SelectQuest(nIndex)
	self.mapQuest = nil
	self.mapQuest = self.tbSelectableQuest[nIndex]
	table.remove(self.tbSelectableQuest, nIndex)
	self:ClearSelectableQuest()
	EventManager.Hit("PenguinCard_SelectQuest")
	if NovaAPI.IsEditorPlatform() then
		printLog("领取任务：" .. "  " .. self.mapQuest.nId)
	end
end
function PenguinLevel:CompleteQuest()
	local mapData = self:CreateBuff(self.mapQuest.nBuffId)
	mapData:ResetAllTrigger()
	self:AddBuff(mapData, true)
end
function PenguinLevel:ChangeHp(nChange)
	self.nHp = self.nHp + nChange
	if NovaAPI.IsEditorPlatform() then
		printLog("Hp变化：" .. "  " .. nChange .. "  当前：" .. self.nHp)
	end
	EventManager.Hit("PenguinCard_ChangeHp", nChange)
	if self.nHp <= 0 then
		self:TriggerEffect(GameEnum.PenguinCardTriggerPhase.FatalDamage, {nHpChange = nChange})
	end
end
function PenguinLevel:AddBuff(mapBuff, bWaitShow)
	if mapBuff.bOnly then
		local nBuffCount = #self.tbBuff
		for i = nBuffCount, 1, -1 do
			if mapBuff.nId == self.tbBuff[i].nId then
				self:DeleteBuff(i)
			end
		end
		table.insert(self.tbBuff, mapBuff)
		EventManager.Hit("PenguinCard_AddBuff", mapBuff, bWaitShow)
	else
		local nHasKey = 0
		for k, v in pairs(self.tbBuff) do
			if v.nId == mapBuff.nId then
				nHasKey = k
				break
			end
		end
		if 0 < nHasKey then
			self.tbBuff[nHasKey]:AddGrowthLayer()
		else
			table.insert(self.tbBuff, mapBuff)
			EventManager.Hit("PenguinCard_AddBuff", mapBuff, bWaitShow)
		end
	end
	if NovaAPI.IsEditorPlatform() then
		printLog("获得buff：" .. "  " .. mapBuff.nId)
	end
end
function PenguinLevel:DeleteBuff(i, nDelayTime)
	self:RecycleBuff(self.tbBuff[i])
	table.remove(self.tbBuff, i)
	EventManager.Hit("PenguinCard_DeleteBuff", i, nDelayTime)
end
function PenguinLevel:RecycleBuff(mapBuff)
	mapBuff:Clear()
	table.insert(self.tbBuffPool, mapBuff)
end
function PenguinLevel:CreateBuff(nId)
	local mapBuff
	if next(self.tbBuffPool) == nil then
		mapBuff = PenguinCardBuff.new(nId)
	else
		mapBuff = table.remove(self.tbBuffPool, 1)
		mapBuff:Init(nId)
	end
	return mapBuff
end
function PenguinLevel:RecycleQuest(mapQuest)
	mapQuest:Clear()
	table.insert(self.tbQuestPool, mapQuest)
end
function PenguinLevel:CreateQuest(nId)
	local mapQuest
	if next(self.tbQuestPool) == nil then
		mapQuest = PenguinCardQuest.new(nId)
	else
		mapQuest = table.remove(self.tbQuestPool, 1)
		mapQuest:Init(nId)
	end
	return mapQuest
end
function PenguinLevel:RunState_Prepare()
	self.nCurTurn = self.nCurTurn + 1
	self.nCurRound = 0
	self.nTurnBuyCount = 0
	self.nTurnScore = 0
	self.tbHandRankCount = {}
	self.tbSelectablePenguinCard = {}
	self.bSelectedPenguinCard = false
	self.nUpgradeDiscount = 1
	self.nTempAddRound = 0
	self.nTempAddRollCount = 0
	for _, v in ipairs(self.tbBuff) do
		v:ResetTurnTrigger()
	end
	for _, v in ipairs(self.tbPenguinCard) do
		if v ~= 0 then
			v:ResetTurnTrigger()
		end
	end
	self:TriggerEffect(GameEnum.PenguinCardTriggerPhase.Prepare)
	self:TriggerEffect(GameEnum.PenguinCardTriggerPhase.BeforeUpgrade)
	self:FreeRollPenguinCard()
	EventManager.Hit("PenguinCard_RunState_Prepare")
end
function PenguinLevel:QuitState_Prepare(nNextState)
	self:ClearSelectablePenguinCard()
	self.nTurnBuyCount = 0
	self.tbSelectablePenguinCard = {}
	self.bSelectedPenguinCard = false
	self.bPreTurnWin = false
	EventManager.Hit("PenguinCard_QuitState_Prepare", nNextState)
	local nWaitTime = 0
	if nNextState == PenguinCardUtils.GameState.Start then
		nWaitTime = 0.6
	elseif nNextState == PenguinCardUtils.GameState.Dealing then
		nWaitTime = 0.45
	elseif nNextState == PenguinCardUtils.GameState.Complete then
		nWaitTime = 0.6
	end
	return nWaitTime
end
function PenguinLevel:GetRoundLimitInTurn()
	return self.nRoundLimit + self.nTempAddRound
end
function PenguinLevel:AddRound()
	if self.nRoundLimit == self.nMaxRound then
		EventManager.Hit(EventId.OpenMessageBox, {
			nType = AllEnum.MessageBox.Tips,
			sSound = "Mode_Card_refresh_falied",
			sContent = ConfigTable.GetUIText("PenguinCard_AddBtnMaxLevel")
		})
		return
	end
	local nCost = self.tbRoundUpgradeCost[self.nRoundLimit + 1] * self.nUpgradeDiscount
	if nCost > self.nScore then
		EventManager.Hit(EventId.OpenMessageBox, {
			nType = AllEnum.MessageBox.Tips,
			sSound = "Mode_Card_refresh_falied",
			sContent = ConfigTable.GetUIText("PenguinCard_NotEnoughScoreUpgrade")
		})
		return
	end
	self.nRoundLimit = self.nRoundLimit + 1
	self:ChangeScore(-1 * nCost)
	EventManager.Hit(EventId.OpenMessageBox, {
		nType = AllEnum.MessageBox.Tips,
		sSound = "Mode_Card_buy",
		sContent = orderedFormat(ConfigTable.GetUIText("PenguinCard_AddRoundSuccess"), self.nRoundLimit)
	})
	self:AfterUpgrade(nCost)
	EventManager.Hit("PenguinCard_AddRound")
end
function PenguinLevel:AddSlot()
	if self.nSlotCount == self.nMaxSlot then
		EventManager.Hit(EventId.OpenMessageBox, {
			nType = AllEnum.MessageBox.Tips,
			sSound = "Mode_Card_refresh_falied",
			sContent = ConfigTable.GetUIText("PenguinCard_AddBtnMaxLevel")
		})
		return
	end
	local nCost = self.tbSlotUpgradeCost[self.nSlotCount + 1] * self.nUpgradeDiscount
	if nCost > self.nScore then
		EventManager.Hit(EventId.OpenMessageBox, {
			nType = AllEnum.MessageBox.Tips,
			sSound = "Mode_Card_refresh_falied",
			sContent = ConfigTable.GetUIText("PenguinCard_NotEnoughScoreUpgrade")
		})
		return
	end
	self.nSlotCount = self.nSlotCount + 1
	self:ChangeScore(-1 * nCost)
	EventManager.Hit(EventId.OpenMessageBox, {
		nType = AllEnum.MessageBox.Tips,
		sSound = "Mode_Card_buy",
		sContent = orderedFormat(ConfigTable.GetUIText("PenguinCard_AddSlotSuccess"), self.nSlotCount)
	})
	self:AfterUpgrade(nCost)
	EventManager.Hit("PenguinCard_AddSlot")
end
function PenguinLevel:AddRoll()
	if self.nBuyLimit == self.nMaxBuyLimit then
		EventManager.Hit(EventId.OpenMessageBox, {
			nType = AllEnum.MessageBox.Tips,
			sSound = "Mode_Card_refresh_falied",
			sContent = ConfigTable.GetUIText("PenguinCard_AddBtnMaxLevel")
		})
		return
	end
	local nCost = self.tbBuyLimitUpgradeCost[self.nBuyLimit + 1] * self.nUpgradeDiscount
	if nCost > self.nScore then
		EventManager.Hit(EventId.OpenMessageBox, {
			nType = AllEnum.MessageBox.Tips,
			sSound = "Mode_Card_refresh_falied",
			sContent = ConfigTable.GetUIText("PenguinCard_NotEnoughScoreUpgrade")
		})
		return
	end
	self.nBuyLimit = self.nBuyLimit + 1
	self:ChangeScore(-1 * nCost)
	EventManager.Hit(EventId.OpenMessageBox, {
		nType = AllEnum.MessageBox.Tips,
		sSound = "Mode_Card_buy",
		sContent = orderedFormat(ConfigTable.GetUIText("PenguinCard_AddRollSuccess"), self.nBuyLimit)
	})
	self:AfterUpgrade(nCost)
	EventManager.Hit("PenguinCard_AddRoll")
end
function PenguinLevel:AfterUpgrade(nUpgradeCost)
	self.nUpgradeDiscount = 1
	self:TriggerEffect(GameEnum.PenguinCardTriggerPhase.AfterUpgrade, {nUpgradeCost = nUpgradeCost})
	self:TriggerEffect(GameEnum.PenguinCardTriggerPhase.BeforeUpgrade)
end
function PenguinLevel:FreeRollPenguinCard()
	local tbId = self:GetRollPenguinCardResult()
	if next(tbId) == nil then
		EventManager.Hit(EventId.OpenMessageBox, {
			nType = AllEnum.MessageBox.Tips,
			sSound = "Mode_Card_refresh_falied",
			sContent = ConfigTable.GetUIText("PenguinCard_Error_EmptyPenguinCard")
		})
		return
	end
	self:ClearSelectablePenguinCard()
	for _, nId in ipairs(tbId) do
		local mapCard = self:CreatePenguinCard(nId)
		table.insert(self.tbSelectablePenguinCard, mapCard)
	end
	self.bSelectedPenguinCard = false
end
function PenguinLevel:RollPenguinCard()
	if self.nTurnBuyCount >= self.nBuyLimit then
		EventManager.Hit(EventId.OpenMessageBox, {
			nType = AllEnum.MessageBox.Tips,
			sSound = "Mode_Card_refresh_falied",
			sContent = ConfigTable.GetUIText("PenguinCard_RollMax")
		})
		return
	end
	local nCost = self:GetRollPenguinCardCost()
	if nCost > self.nScore then
		EventManager.Hit(EventId.OpenMessageBox, {
			nType = AllEnum.MessageBox.Tips,
			sSound = "Mode_Card_refresh_falied",
			sContent = ConfigTable.GetUIText("PenguinCard_NotEnoughScoreRoll")
		})
		return
	end
	local tbId = self:GetRollPenguinCardResult()
	if next(tbId) == nil then
		EventManager.Hit(EventId.OpenMessageBox, {
			nType = AllEnum.MessageBox.Tips,
			sSound = "Mode_Card_refresh_falied",
			sContent = ConfigTable.GetUIText("PenguinCard_Error_EmptyPenguinCard")
		})
		return
	end
	self.nTurnBuyCount = self.nTurnBuyCount + 1
	self:ChangeScore(-1 * nCost)
	self:ClearSelectablePenguinCard()
	for _, nId in ipairs(tbId) do
		local mapCard = self:CreatePenguinCard(nId)
		table.insert(self.tbSelectablePenguinCard, mapCard)
	end
	self.bSelectedPenguinCard = false
	self:TriggerEffect(GameEnum.PenguinCardTriggerPhase.ManualRoll)
	EventManager.Hit("PenguinCard_RollPenguinCard")
end
function PenguinLevel:SelectPenguinCard(nIndex)
	local mapSelectCard = self.tbSelectablePenguinCard[nIndex]
	local bUpgrade, nAimIndex = self:CheckUpgradePenguinCard(mapSelectCard)
	if not bUpgrade and self:GetOwnPenguinCardCount() >= self.nSlotCount then
		EventManager.Hit(EventId.OpenMessageBox, ConfigTable.GetUIText("PenguinCard_SlotMax"))
		return
	end
	if bUpgrade then
		local nAddLevel = mapSelectCard.nLevel
		self.tbPenguinCard[nAimIndex]:Upgrade(nAddLevel)
	else
		local mapCard = self:CreatePenguinCard(mapSelectCard.nId)
		self.tbPenguinCard[nAimIndex] = mapCard
	end
	self.tbPenguinCard[nAimIndex]:SetSlotIndex(nAimIndex)
	self.tbPenguinCard[nAimIndex]:ResetAllTrigger()
	self.bSelectedPenguinCard = true
	self.nGetPenguinCardCount = self.nGetPenguinCardCount + 1
	self:AfterChangePenguinCard()
	EventManager.Hit("PenguinCard_SelectPenguinCard", nAimIndex, bUpgrade)
end
function PenguinLevel:AfterChangePenguinCard()
	local nAllLevel = 0
	for _, v in ipairs(self.tbPenguinCard) do
		if v ~= 0 then
			nAllLevel = nAllLevel + v.nLevel
		end
	end
	self:TriggerEffect(GameEnum.PenguinCardTriggerPhase.PenguinCardChange, {PenguinCardLevel = nAllLevel})
end
function PenguinLevel:CheckUpgradePenguinCard(mapSelectCard)
	local bUpgrade = false
	local nFirstEmpty = 0
	local nAimIndex = 0
	for i, v in ipairs(self.tbPenguinCard) do
		if v == 0 and nFirstEmpty == 0 then
			nFirstEmpty = i
		end
		if v ~= 0 and v.nGroupId == mapSelectCard.nGroupId then
			bUpgrade = true
			nAimIndex = i
			break
		end
	end
	if not bUpgrade then
		nAimIndex = nFirstEmpty
	end
	return bUpgrade, nAimIndex
end
function PenguinLevel:SalePenguinCard(nIndex)
	self:ChangeScore(self.tbPenguinCard[nIndex].nSoldPrice)
	local mapCard = self.tbPenguinCard[nIndex]
	local nGroupId = mapCard.nGroupId
	self:RecyclePenguinCard(mapCard)
	self.tbPenguinCard[nIndex] = 0
	self:AfterChangePenguinCard()
	EventManager.Hit("PenguinCard_SalePenguinCard", nIndex, nGroupId)
end
function PenguinLevel:GetRollPenguinCardCost()
	local findIntervalIndex = function(x, starts)
		if not starts or #starts == 0 or x < starts[1] then
			return 1
		end
		local low, high = 1, #starts
		local best = 1
		while low <= high do
			local mid = math.floor((low + high) / 2)
			if x >= starts[mid] then
				best = mid
				low = mid + 1
			else
				high = mid - 1
			end
		end
		return best
	end
	local mapData = self.mapBuyCost[self.nTurnBuyCount + 1]
	local nIndex = findIntervalIndex(self.nCurTurn, mapData.Turn)
	local nCost = mapData.Cost[nIndex]
	return nCost
end
function PenguinLevel:ClearSelectablePenguinCard()
	if next(self.tbSelectablePenguinCard) ~= nil then
		for i = #self.tbSelectablePenguinCard, 1, -1 do
			local mapCard = table.remove(self.tbSelectablePenguinCard, i)
			self:RecyclePenguinCard(mapCard)
		end
	end
end
function PenguinLevel:GetRollPenguinCardResult()
	local mapWeightCfg = ConfigTable.GetData("PenguinCardWeight", self.nWeightGroupId * 100 + self.nCurTurn)
	if not mapWeightCfg then
		return {}
	end
	local tbWeight = clone(mapWeightCfg.Weight)
	self:AddPenguinCardWeightByTendency(tbWeight, mapWeightCfg.CardList)
	local tbMaxGroupId = self:GetMaxLevelPenguinCard()
	local nRoll = self.nPenguinCardRollCount + self.nTempAddRollCount
	local tbId = PenguinCardUtils.WeightedRandom(mapWeightCfg.CardList, tbWeight, nRoll, tbMaxGroupId)
	return tbId
end
function PenguinLevel:AddPenguinCardWeightByTendency(tbWeight, tbCardList)
	local tbCardAdd = {}
	local tbTendencyId = self:GetRollPenguinCardTendency()
	for _, nTendencyId in pairs(tbTendencyId) do
		local mapTendencyCfg = ConfigTable.GetData("PenguinCardTendency", nTendencyId)
		if mapTendencyCfg then
			local mapAddWeight = {}
			for i, v in ipairs(mapTendencyCfg.CardGroup) do
				mapAddWeight[v] = mapTendencyCfg.AddWeight[i]
			end
			for i, v in ipairs(tbCardList) do
				local mapCardCfg = ConfigTable.GetData("PenguinCard", v)
				if mapCardCfg and mapAddWeight[mapCardCfg.GroupId] then
					tbWeight[i] = tbWeight[i] + mapAddWeight[mapCardCfg.GroupId]
					if not tbCardAdd[v] then
						tbCardAdd[v] = 0
					end
					tbCardAdd[v] = tbCardAdd[v] + mapAddWeight[mapCardCfg.GroupId]
				end
			end
		end
	end
	return tbCardAdd
end
function PenguinLevel:GetRollPenguinCardTendency()
	local mapTendency = {}
	for _, v in ipairs(self.tbPenguinCard) do
		if v ~= 0 and 0 < v.nTendencyGroup then
			if not mapTendency[v.nTendencyGroup] then
				mapTendency[v.nTendencyGroup] = 0
			end
			mapTendency[v.nTendencyGroup] = mapTendency[v.nTendencyGroup] + v.nTendencyScore
		end
	end
	local tbTendencyId = {}
	for nGroup, nScore in pairs(mapTendency) do
		local tbScore = self.mapTendencyScore[nGroup]
		local nLevel = 0
		for k, v in ipairs(tbScore) do
			if v <= nScore then
				nLevel = k
			end
		end
		if 0 < nLevel then
			local nTendencyId = nGroup * 100 + nLevel
			table.insert(tbTendencyId, nTendencyId)
		end
	end
	return tbTendencyId
end
function PenguinLevel:GetMaxLevelPenguinCard()
	local tbGroupId = {}
	for _, v in ipairs(self.tbPenguinCard) do
		if v ~= 0 and v.nLevel == v.nMaxLevel then
			table.insert(tbGroupId, v.nGroupId)
		end
	end
	return tbGroupId
end
function PenguinLevel:ChangeSpecificCard(tbAimId)
	if next(self.tbSelectablePenguinCard) == nil then
		return
	end
	local tbMaxGroupId = self:GetMaxLevelPenguinCard()
	for i = #tbAimId, 1, -1 do
		local mapCardCfg = ConfigTable.GetData("PenguinCard", tbAimId[i])
		if mapCardCfg and table.indexof(tbMaxGroupId, mapCardCfg.GroupId) > 0 then
			table.remove(tbAimId, i)
		end
	end
	if next(tbAimId) == nil then
		return
	end
	local nHasIndex = 0
	for i, v in ipairs(self.tbSelectablePenguinCard) do
		if 0 < table.indexof(tbAimId, v.nId) then
			nHasIndex = i
			v:SetHighLight(true)
			break
		end
	end
	if nHasIndex == 0 then
		local nAimId = tbAimId[math.random(#tbAimId)]
		local tbAimIndex = {}
		for i, v in ipairs(self.tbSelectablePenguinCard) do
			if not v.bHighLight then
				table.insert(tbAimIndex, i)
			end
		end
		if next(tbAimIndex) == nil then
			return
		end
		local nAimIndex = tbAimIndex[math.random(#tbAimIndex)]
		self.tbSelectablePenguinCard[nAimIndex]:Init(nAimId)
		self.tbSelectablePenguinCard[nAimIndex]:SetHighLight(true)
	end
end
function PenguinLevel:RecyclePenguinCard(mapCard)
	mapCard:Clear()
	table.insert(self.tbPenguinCardPool, mapCard)
end
function PenguinLevel:CreatePenguinCard(nId)
	local mapCard
	if next(self.tbPenguinCardPool) == nil then
		mapCard = PenguinCard.new(nId)
	else
		mapCard = table.remove(self.tbPenguinCardPool, 1)
		mapCard:Init(nId)
	end
	return mapCard
end
function PenguinLevel:RunState_Dealing()
	self.nCurRound = self.nCurRound + 1
	self.nTotalRound = self.nTotalRound + 1
	self.tbHandRank = {}
	self.nHandRankId = 0
	self.mapAllSuit = {}
	self.nRoundScore = 0
	self.nRoundValue = 0
	self.nRoundRatio = 1
	self.nRoundMultiRatio = 0
	self.mapCalBaseCardPool = clone(self.mapBaseCardPool)
	for _, v in ipairs(self.tbBuff) do
		v:ResetRoundTrigger()
	end
	for _, v in ipairs(self.tbPenguinCard) do
		if v ~= 0 then
			v:ResetRoundTrigger()
		end
	end
	self:TriggerEffect(GameEnum.PenguinCardTriggerPhase.Dealing)
	self.tbBaseCardId = PenguinCardUtils.WeightedRandom(self.mapCalBaseCardPool.tbId, self.mapCalBaseCardPool.tbWeight, self.nBaseCardCount, {}, true)
	if 0 < self.nFixedTurnGroupId then
		local nFixedId = self.nFixedTurnGroupId * 10000 + self.nCurTurn * 100 + self.nCurRound
		local mapFixedCfg = ConfigTable.GetData("PenguinCardFixedTurn", nFixedId, true)
		if mapFixedCfg then
			self.tbBaseCardId = mapFixedCfg.BaseCardId
		end
	end
	self.tbShowedCard = {}
	for i = 1, self.nBaseCardCount do
		self.tbShowedCard[i] = false
	end
	EventManager.Hit("PenguinCard_RunState_Dealing")
	self:SwitchGameState()
end
function PenguinLevel:QuitState_Dealing(nNextState)
	EventManager.Hit("PenguinCard_QuitState_Dealing", nNextState)
	local nWaitTime = 0
	if nNextState == PenguinCardUtils.GameState.Start then
		nWaitTime = 0.6
	elseif nNextState == PenguinCardUtils.GameState.Flip then
		nWaitTime = 0.85
	elseif nNextState == PenguinCardUtils.GameState.Complete then
		nWaitTime = 0.6
	end
	return nWaitTime
end
function PenguinLevel:ChangeBaseCardWeight(tbChangeWeight)
	for k, v in pairs(tbChangeWeight) do
		local nIndex = table.indexof(self.mapCalBaseCardPool.tbId, tonumber(k))
		self.mapCalBaseCardPool.tbWeight[nIndex] = self.mapCalBaseCardPool.tbWeight[nIndex] + v
	end
end
function PenguinLevel:RunState_Flip()
	EventManager.Hit("PenguinCard_RunState_Flip")
	self:PlayAuto()
end
function PenguinLevel:QuitState_Flip(nNextState)
	self:StopAuto()
	EventManager.Hit("PenguinCard_QuitState_Flip", nNextState)
	local nWaitTime = 0
	if nNextState == PenguinCardUtils.GameState.Start then
		nWaitTime = 0.6
	elseif nNextState == PenguinCardUtils.GameState.Settlement then
		nWaitTime = 1
	elseif nNextState == PenguinCardUtils.GameState.Complete then
		nWaitTime = 0.6
	end
	return nWaitTime
end
function PenguinLevel:ShowBaseCard(nIndex)
	local add = function(i)
		if self.tbShowedCard[i] == false then
			self.tbShowedCard[i] = true
			local nId = self.tbBaseCardId[i]
			local mapCfg = ConfigTable.GetData("PenguinBaseCard", nId)
			if mapCfg then
				if not self.mapAllSuit[mapCfg.Suit1] then
					self.mapAllSuit[mapCfg.Suit1] = 0
				end
				self.mapAllSuit[mapCfg.Suit1] = self.mapAllSuit[mapCfg.Suit1] + mapCfg.SuitCount1
				local SuitCards = {}
				if 0 < mapCfg.SuitCount1 then
					table.insert(SuitCards, mapCfg.Suit1)
				end
				if 0 < mapCfg.SuitCount2 then
					table.insert(SuitCards, mapCfg.Suit2)
				end
				local SuitCount = {}
				if 0 < mapCfg.SuitCount1 then
					SuitCount[mapCfg.Suit1] = mapCfg.SuitCount1
				end
				if 0 < mapCfg.SuitCount2 then
					SuitCount[mapCfg.Suit2] = mapCfg.SuitCount2
				end
				self:TriggerEffect(GameEnum.PenguinCardTriggerPhase.Flip, {
					SuitCards = SuitCards,
					SuitCount = SuitCount,
					BaseCard = {nId = nId, nIndex = i}
				})
			end
			local mapAfterCfg = ConfigTable.GetData("PenguinBaseCard", self.tbBaseCardId[i])
			if mapAfterCfg then
				self:TriggerEffect(GameEnum.PenguinCardTriggerPhase.FlipEnd, {
					BaseCard = {
						nId = self.tbBaseCardId[i],
						nIndex = i
					}
				})
				if self.mapQuest ~= nil then
					self.mapQuest:AddProgress(GameEnum.PenguinCardQuestType.SuitCount, {
						nId = mapAfterCfg.Suit1,
						nCount = mapAfterCfg.SuitCount1
					})
				end
			end
		end
	end
	local bAll = nIndex == nil
	if bAll then
		for i = 1, self.nBaseCardCount do
			add(i)
		end
	else
		add(nIndex)
	end
	local nShowed = self:GetShowedCardCount()
	if nShowed == self.nBaseCardCount then
		self:CheckHandRank()
		self:SwitchGameState()
	end
	EventManager.Hit("PenguinCard_ShowBaseCard", nIndex)
end
function PenguinLevel:CheckHandRank()
	local tbAllSuit = {}
	for k, v in pairs(self.mapAllSuit) do
		table.insert(tbAllSuit, {nSuit = k, nCount = v})
	end
	table.sort(tbAllSuit, function(a, b)
		return a.nCount > b.nCount
	end)
	for _, v in ipairs(self.mapHandRankRule) do
		self.tbHandRank = {}
		local tbCount = v.SuitCount
		local nType = #tbCount
		local nHasType = #tbAllSuit
		local nAble = 0
		if nType <= nHasType then
			for i = 1, nType do
				if tbAllSuit[i].nCount >= tbCount[i] then
					nAble = nAble + 1
					for _ = 1, tbCount[i] do
						table.insert(self.tbHandRank, tbAllSuit[i].nSuit)
					end
				end
			end
		end
		if nAble == nType then
			self.nHandRankId = v.Id
			if not self.tbHandRankCount[self.nHandRankId] then
				self.tbHandRankCount[self.nHandRankId] = 0
			end
			self.tbHandRankCount[self.nHandRankId] = self.tbHandRankCount[self.nHandRankId] + 1
			self:ChangeRoundScore(v.Value, v.Ratio, 0, true)
			if self.mapQuest ~= nil then
				self.mapQuest:AddProgress(GameEnum.PenguinCardQuestType.HandRank, {
					nId = self.nHandRankId,
					nCount = 1
				})
			end
			break
		end
	end
end
function PenguinLevel:ChangeRoundScore(nAddValue, nAddRatio, nAddMultiRatio, bFromHandRank)
	local nBeforeScore = self.nRoundScore
	local nBeforeBase = self.nRoundValue
	local nBeforeMultiRatio = self.nRoundMultiRatio
	local nBeforeRatio = self.nRoundRatio
	self.nRoundValue = self.nRoundValue + nAddValue
	if 0 < nAddMultiRatio then
		if self.nRoundMultiRatio == 0 then
			self.nRoundMultiRatio = 1
		end
		self.nRoundMultiRatio = self.nRoundMultiRatio + (nAddMultiRatio - 1)
	end
	self.nRoundRatio = self.nRoundRatio + nAddRatio
	local nBeforeAllRatio = 0 < nBeforeMultiRatio and nBeforeMultiRatio * nBeforeRatio or nBeforeRatio
	local nAfterAllRatio = self.nRoundMultiRatio > 0 and self.nRoundRatio * self.nRoundMultiRatio or self.nRoundRatio
	nBeforeAllRatio = math.floor(nBeforeAllRatio * 100) / 100
	nAfterAllRatio = math.floor(nAfterAllRatio * 100) / 100
	self.nRoundScore = self.nRoundValue * nAfterAllRatio
	local nAddScore = self.nRoundScore - nBeforeScore
	self.nTurnScore = self.nTurnScore + nAddScore
	if self.nTurnScore > self.nBestTurnScore then
		self.nBestTurnScore = self.nTurnScore
	end
	if self.nRoundScore > self.nBestRoundScore then
		self.nBestRoundScore = self.nRoundScore
	end
	EventManager.Hit("PenguinCard_ChangeRoundScore", nBeforeBase, nBeforeAllRatio, nBeforeScore, bFromHandRank)
	if NovaAPI.IsEditorPlatform() then
		printLog("轮积分变化：" .. nAddScore .. "  (" .. nBeforeScore .. " -> " .. self.nRoundScore .. ")")
		printLog("基础变化：" .. nAddValue .. "  (" .. nBeforeBase .. " -> " .. self.nRoundValue .. ")")
		printLog("倍率变化：" .. nAfterAllRatio - nBeforeAllRatio .. "  (" .. nBeforeAllRatio .. " -> " .. nAfterAllRatio .. ")")
	end
end
function PenguinLevel:GetShowedCardCount()
	local nShowed = 0
	for _, v in pairs(self.tbShowedCard) do
		if v then
			nShowed = nShowed + 1
		end
	end
	return nShowed
end
function PenguinLevel:ReplaceBaseCard(nIndex, nBeforeId, nAfterId)
	local mapBeforeCfg = ConfigTable.GetData("PenguinBaseCard", nBeforeId)
	local mapAfterCfg = ConfigTable.GetData("PenguinBaseCard", nAfterId)
	if not mapBeforeCfg or not mapAfterCfg then
		return
	end
	self.mapAllSuit[mapBeforeCfg.Suit1] = self.mapAllSuit[mapBeforeCfg.Suit1] - mapBeforeCfg.SuitCount1
	if not self.mapAllSuit[mapAfterCfg.Suit1] then
		self.mapAllSuit[mapAfterCfg.Suit1] = 0
	end
	self.mapAllSuit[mapAfterCfg.Suit1] = self.mapAllSuit[mapAfterCfg.Suit1] + mapAfterCfg.SuitCount1
	self.tbBaseCardId[nIndex] = nAfterId
	EventManager.Hit("PenguinCard_ReplaceBaseCard", nIndex)
end
function PenguinLevel:RunState_Settlement()
	if not self.mapHandRankHistory[self.nHandRankId] then
		self.mapHandRankHistory[self.nHandRankId] = 0
	end
	self.mapHandRankHistory[self.nHandRankId] = self.mapHandRankHistory[self.nHandRankId] + 1
	local HandRankSuitCount = {}
	for _, v in ipairs(self.tbHandRank) do
		if not HandRankSuitCount[v] then
			HandRankSuitCount[v] = 0
		end
		HandRankSuitCount[v] = HandRankSuitCount[v] + 1
		if not self.mapSuitHistory[v] then
			self.mapSuitHistory[v] = 0
		end
		self.mapSuitHistory[v] = self.mapSuitHistory[v] + 1
	end
	self:TriggerEffect(GameEnum.PenguinCardTriggerPhase.Settlement, {
		HandRankSuitCount = HandRankSuitCount,
		SuitCount = self.mapAllSuit,
		HandRank = self.nHandRankId,
		HandRankCount = self.tbHandRankCount
	})
	self:AddLog()
	EventManager.Hit("PenguinCard_RunState_Settlement")
	self:PlayAuto()
end
function PenguinLevel:QuitState_Settlement(nNextState)
	self:StopAuto()
	self:ChangeScore(self.nRoundScore)
	if self.mapQuest ~= nil then
		self.mapQuest:AddProgress(GameEnum.PenguinCardQuestType.Score, {
			nCount = self.nRoundScore
		})
	end
	if self:GetRoundLimitInTurn() == self.nCurRound then
		self:EndTurn()
	end
	self.tbHandRank = {}
	self.nHandRankId = 0
	self.mapAllSuit = {}
	self.nRoundScore = 0
	self.nRoundValue = 0
	self.nRoundRatio = 1
	self.nRoundMultiRatio = 0
	self.mapCalBaseCardPool = {}
	EventManager.Hit("PenguinCard_QuitState_Settlement", nNextState)
	local nWaitTime = 0
	if nNextState == PenguinCardUtils.GameState.Start then
		nWaitTime = 0.6
	elseif nNextState == PenguinCardUtils.GameState.Dealing then
		nWaitTime = 0.57
	elseif nNextState == PenguinCardUtils.GameState.Prepare then
		nWaitTime = 0.57
	elseif nNextState == PenguinCardUtils.GameState.Complete then
		nWaitTime = 0.6
	end
	return nWaitTime
end
function PenguinLevel:EndTurn()
	local nBuffCount = #self.tbBuff
	for i = nBuffCount, 1, -1 do
		local bAble = self.tbBuff[i]:AddDuration_Turn()
		if not bAble then
			self:DeleteBuff(i)
		end
	end
	if self.mapQuest ~= nil then
		self.mapQuest:AddTurnCount()
	end
end
function PenguinLevel:AddLog()
	if not self.mapLog[self.nCurTurn] then
		self.mapLog[self.nCurTurn] = {
			nTurnScore = 0,
			tbRound = {}
		}
	end
	self.mapLog[self.nCurTurn].nTurnScore = self.nTurnScore
	if not self.mapLog[self.nCurTurn].tbRound[self.nCurRound] then
		self.mapLog[self.nCurTurn].tbRound[self.nCurRound] = {
			nRoundScore = 0,
			tbHandRank = {}
		}
	end
	self.mapLog[self.nCurTurn].tbRound[self.nCurRound].nRoundScore = self.nRoundScore
	self.mapLog[self.nCurTurn].tbRound[self.nCurRound].tbHandRank = clone(self.tbHandRank)
	self.mapLog[self.nCurTurn].tbRound[self.nCurRound].nHandRankId = self.nHandRankId
end
function PenguinLevel:RunState_Complete(mapParam)
	self.nStar = self:GetStar()
	EventManager.Hit("PenguinCard_RunState_Complete")
	if self.nActId then
		local tab = {}
		table.insert(tab, {
			"role_id",
			tostring(PlayerData.Base._nPlayerId)
		})
		table.insert(tab, {
			"activity_id",
			tostring(self.nActId)
		})
		table.insert(tab, {
			"battle_id",
			tostring(self.nLevelId)
		})
		table.insert(tab, {
			"round",
			tostring(self.nCurTurn)
		})
		table.insert(tab, {
			"result",
			tostring(self.nStar == 0 and 2 or 1)
		})
		local nEnd = mapParam and mapParam.bManual == true and 2 or 1
		table.insert(tab, {
			"end_type",
			tostring(nEnd)
		})
		table.insert(tab, {
			"score",
			tostring(self.nScore)
		})
		table.insert(tab, {
			"star",
			tostring(self.nStar)
		})
		local sId = ""
		for i = 1, 6 do
			if self.tbPenguinCard[i] ~= 0 then
				if sId == "" then
					sId = sId .. self.tbPenguinCard[i].nId
				else
					sId = sId .. "," .. self.tbPenguinCard[i].nId
				end
			end
		end
		table.insert(tab, {"card_list", sId})
		table.insert(tab, {
			"skill_1",
			tostring(self.nRoundLimit)
		})
		table.insert(tab, {
			"skill_2",
			tostring(self.nSlotCount)
		})
		table.insert(tab, {
			"skill_3",
			tostring(self.nBuyLimit)
		})
		NovaAPI.UserEventUpload("minigame_PenguinCard", tab)
	end
end
function PenguinLevel:QuitState_Complete()
	self.nStar = 0
	EventManager.Hit("PenguinCard_QuitState_Complete")
	return 0
end
function PenguinLevel:GetMostHandRank()
	local nCount = 0
	local nId = 0
	for k, v in pairs(self.mapHandRankHistory) do
		if v > nCount then
			nCount = v
			nId = k
		end
	end
	return nId, nCount
end
function PenguinLevel:GetMostSuit()
	local nCount = 0
	local nId = 0
	for k, v in pairs(self.mapSuitHistory) do
		if v > nCount then
			nCount = v
			nId = k
		end
	end
	return nId, nCount
end
function PenguinLevel:GetBestPenguinCard()
	local nCount = 0
	local mapCard
	for _, v in ipairs(self.tbPenguinCard) do
		if v ~= 0 and nCount < v.nLevel then
			nCount = v.nLevel
			mapCard = v
		end
	end
	return mapCard
end
function PenguinLevel:SetAutoState(bAuto)
	self.bAuto = bAuto
	LocalData.SetPlayerLocalData("PenguinCardAuto", self.bAuto)
end
function PenguinLevel:SetAutoSpeed(nSpeed)
	self.nSpeed = nSpeed
	LocalData.SetPlayerLocalData("PenguinCardSpeed", self.nSpeed)
	if self.sequence then
		self:StopAuto()
		self:PlayAuto()
	end
end
function PenguinLevel:PlayAuto(bClick)
	if not self.bAuto or self.bPause then
		return
	end
	if self.nGameState == PenguinCardUtils.GameState.Flip then
		self.sequence = DOTween.Sequence()
		for j = 1, self.nBaseCardCount do
			if self.tbShowedCard[j] == false then
				self.sequence:AppendCallback(function()
					self:ShowBaseCard(j)
				end)
				self.sequence:AppendInterval(0.2 / self.nSpeed)
			end
		end
		self.sequence:SetUpdate(true)
	elseif self.nGameState == PenguinCardUtils.GameState.Settlement then
		local bKeep = not PlayerData.Guide:CheckGuideFinishById(302)
		if EditorSettings and EditorSettings.bJumpGuide then
			bKeep = false
		end
		if bKeep then
			return
		end
		self.sequence = DOTween.Sequence()
		if not bClick then
			self.sequence:AppendInterval((self.nRoundValue >= self.nFireScore and 7 or 5) / self.nSpeed)
		end
		self.sequence:AppendCallback(function()
			EventManager.Hit("PenguinCard_QuitScoreAni")
			if self:GetRoundLimitInTurn() == self.nCurRound and self.nCurTurn < self.nMaxTurn then
				local callback = function()
					self:SwitchGameState()
				end
				EventManager.Hit("PenguinCard_OpenLog", self.nCurTurn, false, callback)
			else
				self:SwitchGameState()
			end
		end)
		self.sequence:SetUpdate(true)
	end
end
function PenguinLevel:StopAuto()
	if self.sequence then
		self.sequence:Kill()
		self.sequence = nil
	end
end
function PenguinLevel:Pause()
	self.bPause = true
	if self.sequence then
		self.sequence:Pause()
	end
	EventManager.Hit("PenguinCard_Pause")
end
function PenguinLevel:Resume()
	self.bPause = false
	if self.sequence then
		self.sequence:Play()
	else
		self:PlayAuto()
	end
	EventManager.Hit("PenguinCard_Resume")
end
function PenguinLevel:ChangeScore(nChange)
	if not nChange or nChange == 0 then
		return
	end
	local nBefore = self.nScore
	self.nScore = self.nScore + nChange
	local nBeforeStar, nStar = 0, 0
	for i, v in ipairs(self.tbStarScore) do
		if v <= nBefore then
			nBeforeStar = i
		end
		if v <= self.nScore then
			nStar = i
		end
	end
	if nBeforeStar == 0 and nStar == 1 and self.nGameState == PenguinCardUtils.GameState.Settlement then
		self.bPreTurnWin = true
	end
	EventManager.Hit("PenguinCard_ChangeScore", nBefore, nBeforeStar, nStar)
	if NovaAPI.IsEditorPlatform() then
		printLog("总积分变化：" .. nChange .. "  (" .. nBefore .. " -> " .. self.nScore .. ")")
	end
end
function PenguinLevel:GetStar()
	local nStar = 0
	for i, v in ipairs(self.tbStarScore) do
		if v <= self.nScore then
			nStar = i
		end
	end
	return nStar
end
function PenguinLevel:GetOwnPenguinCardCount()
	local nCount = 0
	for i = 1, 6 do
		if self.tbPenguinCard[i] ~= 0 then
			nCount = nCount + 1
		end
	end
	return nCount
end
function PenguinLevel:ExecuteEffect(nEffectType, mapEffectValue, mapTriggerSource)
	if nEffectType == GameEnum.PenguinCardEffectType.AddBaseCardWeight then
		self:ChangeBaseCardWeight(mapEffectValue)
	elseif nEffectType == GameEnum.PenguinCardEffectType.ReplaceBaseCard then
		self:ReplaceBaseCard(mapTriggerSource.BaseCard.nIndex, mapTriggerSource.BaseCard.nId, mapEffectValue[1])
	elseif nEffectType == GameEnum.PenguinCardEffectType.IncreaseBasicChips then
		self:ChangeRoundScore(mapEffectValue, 0, 0)
	elseif nEffectType == GameEnum.PenguinCardEffectType.IncreaseMultiplier then
		self:ChangeRoundScore(0, mapEffectValue, 0)
	elseif nEffectType == GameEnum.PenguinCardEffectType.MultiMultiplier then
		self:ChangeRoundScore(0, 0, mapEffectValue)
	elseif nEffectType == GameEnum.PenguinCardEffectType.UpgradeDiscount then
		self.nUpgradeDiscount = mapEffectValue / 100
	elseif nEffectType == GameEnum.PenguinCardEffectType.AddRound then
		self.nTempAddRound = self.nTempAddRound + mapEffectValue
	elseif nEffectType == GameEnum.PenguinCardEffectType.AddCardRollCount then
		self.nTempAddRollCount = self.nTempAddRollCount + mapEffectValue
	elseif nEffectType == GameEnum.PenguinCardEffectType.BlockFatalDamage then
		self:ChangeHp(-1 * mapTriggerSource.nHpChange)
		EventManager.Hit("PenguinCard_BlockFatalDamage")
	elseif nEffectType == GameEnum.PenguinCardEffectType.UpgradeRebate then
		self:ChangeScore(mapTriggerSource.nUpgradeCost * mapEffectValue / 100)
	elseif nEffectType == GameEnum.PenguinCardEffectType.RollSpecificCard then
		self:ChangeSpecificCard(mapEffectValue)
	end
end
function PenguinLevel:TriggerEffect(nTriggerPhase, mapTriggerSource)
	local callback = function(nEffectType, mapEffectValue)
		self:ExecuteEffect(nEffectType, mapEffectValue, mapTriggerSource)
	end
	local nBuffCount = #self.tbBuff
	for i = nBuffCount, 1, -1 do
		local bTriggered = self.tbBuff[i]:Trigger(nTriggerPhase, mapTriggerSource, callback)
		if bTriggered then
			local bAble = self.tbBuff[i]:AddDuration_Count()
			if not bAble then
				local nDelayTime = self.tbBuff[i]:GetDelayTime()
				self:DeleteBuff(i, nDelayTime)
			end
		end
	end
	for _, v in ipairs(self.tbPenguinCard) do
		if v ~= 0 then
			v:Trigger(nTriggerPhase, mapTriggerSource, callback)
			v:Growth(nTriggerPhase, mapTriggerSource)
		end
	end
end
return PenguinLevel