local Passive = require "adv.AdvPassive"
  

  local AdvCommon = require "adv.AdvCommon"
  local AdvMap = require "adv.AdvMap"

  local Buff = require "adv.AdvBuff"

  local Adv = class("Adv")

  local AdvTask = import(".AdvTask")  --任务相关数据搞出去
  AdvTask.bind(Adv)
  

  function Adv:ctor(owner)
  	assert(owner, "Adv instance must have owner(role)")
  	self.owner = owner
  	self.maps = {}

  	self.shopStatus = {}

  	self.battle = nil
  	self.backEvents = {} --发给客户端的事件组

  
  	self.advTask = self.owner:getProperty("advTask")
  	self.advMTask = self.owner:getProperty("advMTask")
  	self.advTaskChange = false -- 任务改变才更新
  

  	self:initByInfo(self.owner:getProperty("advInfo"))

  end
  

  function Adv:log(contents)
  	contents = contents or {}
  	if contents["cint1"] or contents["cint2"] or contents["cint3"] then
  		print("advLog error log have cint1 or cint2 or cint3 ", debug.traceback())
  	end
  	contents["cint1"] = self.chapterId
  	contents["cint2"] = self.level
  
  	self.owner:log("adv_action", contents)
  end
  

  --初始化adv 信息
  function Adv:initByInfo(advInfo)
  	if not next(advInfo) then return end --还没有 开始新地图
  
  	self.chapterId = advInfo.chapterId
  	self.level = advInfo.level or 1

  	self.round = advInfo.round or 0

  	self.score = advInfo.score or {}

  	self.isRelay = advInfo.isRelay

  	self.lastEnemyId = advInfo.lastEId or 1
  	self.mapStack = advInfo.mstack or {}

  	self.lchoose = advInfo.lch or {}

  	self.waitArtifact = advInfo.waitAF

  	self.cacheUnlock = advInfo.cacheUnlock or {}

  	self.shopStatus = advInfo.shopStatus or {}

  	self.support = advInfo.support or {}

  	self.maps = {}
  	for id, map in ipairs(advInfo.maps or {}) do
  		self.maps[id] = AdvMap.new(self, id, map)

  	end

  
  	self:initBattle()

  end

  -- 找出level 是否存在中继层
  function Adv:isHaveRelay(level, chapterId)

  	level = level or self.level

  	chapterId = chapterId or self.chapterId
  	if level == 1 then return end
  	
  	local campsiteCsv = csvdb["adv_chapter_campsiteCsv"][chapterId]
  	for _, campsite in ipairs(campsiteCsv) do
  		if campsite.floor == level then
  			return campsite
  		end
  	end
  	return nil
  end

  -- 随机新的地图

  function Adv:initByChapter(chapterId, level, isToNext, notNotify, isRelay, isEnter, support)

  	if not self.chapterId then -- 开始新的章节
  		self.chapterId = chapterId
  		self:checkAchievement(Adv.AchievType.StartBattle, 1)
  	elseif chapterId ~= self.chapterId then  -- 正常不会出现
  		return 
  	end
  	

  	self.level = level or 1

  	self.round = 0

  	self.score = self.score or {}
  	self.lastEnemyId = 1
  	self.mapStack = {1} -- 最后一个为当前的地图

  	self.lchoose = self.lchoose or {}

  	self.cacheUnlock = self.cacheUnlock or {}

  	self.shopStatus = self.shopStatus or {}

  	self.support = self.support or {}

  	self.battle = nil  -- 清掉 老的 battle

  
  	if isEnter then -- 把 支援效果初始化为易用用的形式
  		self:initSupport(support or {})

  		self.owner:setProperty("advLimit", {}) -- 清掉 Limit

  	end

  	-- 随机出地图

  	local mapId 
  	if isRelay then
  		local relayData = self:isHaveRelay(level, chapterId)
  		if relayData then 
  			mapId = relayData.map
  		else
  			isRelay = false
  			mapId = self:randomMapId(chapterId, level)
  		end
  	else
  		mapId = self:randomMapId(chapterId, level)
  	end
  	self.isRelay = isRelay
  	local isNewRelay = false
  	if self.isRelay then -- 中继层
  		local advRelay = self.owner:getProperty("advRelay")
  		local chapter = self:isEndless() and -1 or self.chapterId
  		if not (advRelay[chapter] or {})[self.level] then
  			isNewRelay = true
  			advRelay[chapter] = advRelay[chapter] or {}
  			advRelay[chapter][self.level] = 1
  			self.owner:updateProperty({field = advRelay, value = advRelay})
  		end
  	end
  

  	self.maps = {}

  	self.maps[1] = AdvMap.new(self, 1, mapId, isEnter, isNewRelay)

  	self:initBattle(true)

  	self:initLayerTask()
  

  	-- 支援效果生效一些
  	self:activeSomeSupport()
  

  	self:checkTask(Adv.TaskType.Arrive)

  	self:checkAdvUnlock(1, self.level)

  	if isToNext then
  		self.battle.player:afterLayer() -- 玩家的buff 清理一下

  	end

  	if not notNotify then
  		self:saveDB(notNotify)

  	end

  end

  function Adv:clear()
  	self.chapterId = nil
  	self.level = nil
  	self.score = {}

  	self.round = 0

  	self.lastEnemyId = 1
  	self.mapStack = {}

  	self.lchoose = {}

  	self.maps = {}
  	self.battle = nil

  	self.waitArtifact = nil

  	self.isRelay = nil

  	self.cacheUnlock = {}

  	self.shopStatus = {}

  	self.support = {}

  end
  

  function Adv:saveDB(notNotify)
  	local advInfo,  advTeam = {}, self.owner:getProperty("advTeam")

  	if self:isRunning() then

  		advInfo.chapterId = self.chapterId
  		advInfo.level = self.level

  		advInfo.round = self.round

  		advInfo.score = self.score

  		advInfo.isRelay = self.isRelay

  		advInfo.lastEId = self.lastEnemyId
  		advInfo.mstack = self.mapStack

  		advInfo.lch = self.lchoose

  		advInfo.waitAF = self.waitArtifact

  		advInfo.cacheUnlock = self.cacheUnlock

  		advInfo.shopStatus = self.shopStatus

  		advInfo.support = self.support

  		advInfo.maps = {}

  		self.battle:saveDB()

  		for id , map in ipairs(self.maps) do
  			advInfo.maps[id] = map:getDB()

  		end

  		advTeam.player = self.battle.player:getDB()

  	else
  		advTeam.player = nil

  	end

  
  	self:updateTask(notNotify)

  	self:updateAchievement(notNotify)

  	self.owner:updateProperties({advInfo = advInfo, advTeam = advTeam}, notNotify)

  end
  

  function Adv:initSupport(supports)
  	self.support = {}
  
  	local supportEffect = {}
  	-- 获得道具 1=道具id=道具数量
  	supportEffect[1] = function(_, itemId, num)
  		self.support[1] = self.support[1] or {}
  		self.support[1][itemId] = (self.support[1][itemId] or 0) + num
  	end
  
  	-- 获得mapbuff  2=mapbuffid
  	supportEffect[2] = function(_, buffId)
  		self.support[2] = self.support[2] or {}
  		table.insert(self.support[2], buffId)
  	end
  
  	-- 获得mappassive 3=mappassive
  	supportEffect[3] = function(_, passiveId)
  		self.support[3] = self.support[3] or {}
  		table.insert(self.support[3], passiveId)
  	end
  
  	-- 首层额外刷新 4=类型=id=数量(类型1=choose/2=building/3=click/4=drop/5=shop)
  	supportEffect[4] = function(_, etype, id, num)
  		self.support[4] = self.support[4] or {}
  		self.support[4][etype] = self.support[4][etype] or {}
  		self.support[4][etype][id] = (self.support[4][etype][id] or 0) + num
  	end
  
  	-- 每层额外刷新 5=类型=id=数量(类型1=choose/2=building/3=click/4=drop/5=shop)
  	supportEffect[5] = function(_, etype, id, num)
  		self.support[5] = self.support[5] or {}
  		self.support[5][etype] = self.support[5][etype] or {}
  		self.support[5][etype][id] = (self.support[5][etype][id] or 0) + num
  	end
  
  	-- 获得随机神器 6=数量
  	supportEffect[6] = function(num)
  		self.support[6] = (self.support[6] or 0) + num
  	end
  
  	-- 获得3选1神器 7=选择次数（连续选择，每次选择重新随机）
  	supportEffect[7] = function(num)
  		self.support[7] = (self.support[7] or 0) + num
  	end
  
  	for _, supportId in ipairs(supports) do
  		local supportData = csvdb["adv_supportCsv"][supportId]
  		for _, effect in ipairs(supportData.effect:toArray()) do
  			local cur = effect:toArray(true, "=")
  			if supportEffect[cur[1]] then
  				supportEffect[cur[1]](table.unpack(cur))
  			end 
  		end
  	end
  end
  
  function Adv:activeSomeSupport()
  	-- 奖励物品
  	if self.support[1] then

  		self:award(self.support[1], {log = {desc = "support"}})

  		self.support[1] = nil
  	end
  
  	-- 加buff
  	if self.support[2] then
  		for _, buffId in ipairs(self.support[2]) do
  			self.battle.player:addBuff(buffId)
  		end
  		self.support[2] = nil
  	end
  
  	--加被动技
  	if self.support[3] then
  		for _, passiveId in ipairs(self.support[3]) do
  			self.battle.player:addPassive({id = passiveId})
  		end
  		self.support[3] = nil
  	end
  
  	-- 加随机神器
  	if self.support[6] then
  		local pool = {}
  		for id, temp in pairs(csvdb["adv_artifactCsv"]) do
  			if not self:isHaveArtifact(id) and self.owner:isArtifactOpen(id, self:isEndless()) then
  				table.insert(pool, id)
  			end
  		end
  		for i = 1, math.min(self.support[6], #pool) do
  			local idx = math.randomInt(1, #pool)

  			self:award({[pool[idx]] = 1}, {log = {desc = "support"}})

  			table.remove(pool, idx)
  		end
  		self.support[6] = nil
  	end
  
  	self:supportChooseArtifact()
  end
  
  function Adv:supportChooseArtifact()
  	-- 加 三选一 神器
  	if self.support[7] then
  		if self.support[7] > 0 then
  			self:waitChooseArtifact()
  		end
  		self.support[7] = self.support[7] - 1
  		if self.support[7] <= 0 then
  			self.support[7] = nil
  		end
  	end
  end
  
  function Adv:supportFirstLayerAddEvent()
  	if self.support[4] then
  		local temp = self.support[4]
  		self.support[4] = nil
  		return temp
  	end
  end
  
  function Adv:supportEveryLayerAddEvent()
  	return self.support[5]
  end
  
  
  function Adv:isRunning()
  	if self.chapterId then return true end
  	return false
  end
  
  -- 强制结束
  function Adv:forceOver(notNotify)
  	if self:isRunning() then

  		local advTeam = self.owner:getProperty("advTeam")
  		advTeam.player = nil
  
  		local reward = self.owner:getProperty("advItems"):toNumMap()
  		for itemId, count in pairs(reward) do
  			reward[itemId] = math.ceil(count * globalCsv.adv_fail_reward_ratio / 100) -- 奖励相当于失败
  		end

  		self.owner:award(reward, {log = {desc = "advOver", int1 = self.chapterId}})

  		self:clear()

  		self.owner:updateProperties({
  			advInfo = {}, 
  			advTeam = advTeam,
  			advItems = "",
  			advAFGet = {},
  			advAFWear = {},
  		}, notNotify)
  	end
  end
  
  
  

  -- 1=抵达x层；2=通关x层；3=完成指定事件；4=完成指定连锁事件
  function Adv:checkAdvUnlock(utype, value)
  	if not self.chapterId then return end
  	local chapter = self.chapterId % 100
  	local reward = {}
  	for id, data in pairs(csvdb["adv_unlockCsv"]) do
  		if data.chapterid == chapter and data.type == utype and value == data.value then
  			--0=立即获得；1=结算时获得
  			if data.time == 0 then
  				reward[data.itemid] = 1
  			elseif data.time == 1 then
  				table.insert(self.cacheUnlock, data.itemid)
  			end
  		end
  	end
  	if next(reward) then

  		self.owner:award(reward, {log = {desc = "advUnlock", int1 = self.chapterId}})

  	end
  end
  
  function Adv:clearAdvUnlockCache()
  	local reward = {}
  	for _, itemId in ipairs(self.cacheUnlock) do
  		reward[itemId] = 1
  	end
  	if next(reward) then

  		self.owner:award(reward, {log = {desc = "advUnlock", int1 = self.chapterId}})

  	end
  	self.cacheUnlock = {}
  end
  

  function Adv:initBattle(notDb)

  	self.battle = require("adv.AdvBattle").new(self)
  	for _, passiveC in ipairs(self.cachePassiveEvent or {}) do
  		self.battle:triggerPassive(passiveC[1], passiveC[2])

  	end

  	self.cachePassiveEvent = {}

  
  	-- after init battle
  	for idx, map in pairs(self.maps) do
  		map:initBattleAfter()
  	end

  	--下层
  	if notDb and self.level ~= 1 then
  		self.battle.player:attrChangeCondBuffCheck(1)
  	end

  end
  

  function Adv:triggerPassive(condType, params)
  	self.cachePassiveEvent = self.cachePassiveEvent or {}
  	if not self.battle then
  		table.insert(self.cachePassiveEvent, {condType, params})
  	else
  		self.battle:triggerPassive(condType, params)
  	end

  end
  

  function Adv:getCurMap()
  	return self.maps[self.mapStack[#self.mapStack]]

  end
  

  function Adv:getCurMapIdx()
  	return self.mapStack[#self.mapStack]

  end
  

  function Adv:getRoom(roomId, mapIdx)
  	mapIdx = mapIdx or self:getCurMapIdx()
  	local map = self.maps[mapIdx]
  	if map then
  		return map.rooms[roomId]

  	end

  end
  

  function Adv:getBlock(roomId, blockId, mapIdx)
  	local room = self:getRoom(roomId, mapIdx)
  	if room then
  		return room.blocks[blockId]

  	end

  end
  

  function Adv:isHaveArtifact(id)
  	return self.owner:getProperty("advAFGet")[id]
  end
  
  function Adv:awardArtifact(id, params)
  	if self:isHaveArtifact(id) then return end
  	self.owner:changeUpdates({{type = "advAFGet", field = id, value = 1}}, params.notNotify)

  	self:checkAchievement(Adv.AchievType.GetMWeapon, 1, id)

  
  
  	if params.log then
  		local log = clone(params.log)
  		if log["cint1"] or log["cint2"] or log["cint3"] then
  			print("awardArtifact error log have cint1 or cint2 or cint3 ", debug.traceback())
  		end
  		log["cint1"] = self.chapterId
  		log["cint2"] = self.level
  		log["cint3"] = id
  		self.owner:log("in_artifact", log)
  	else
  		print("awardArtifact no log ", debug.traceback())
  	end
  

  	self:pushBackEvent(AdvBackEventType.Artifact, {id = id})

  end
  
  

  function Adv:addArtifactEffect(effect)

  	for _, eff in ipairs(effect:toArray()) do
  		local etype, id = table.unpack(eff:toArray(true, "="))
  		if etype == 1 then
  			self.battle.player:addPassive({id = id})
  		elseif etype == 2 then
  			self.battle.player:addBuff(id)
  		end
  	end
  end
  

  function Adv:delArtifactEffect(effect)

  	for _, eff in ipairs(effect:toArray()) do
  		local etype, id = table.unpack(eff:toArray(true, "="))
  		if etype == 1 then
  			self.battle.player:delPassiveById(id)
  		elseif etype == 2 then
  			self.battle.player:delBuffById(id)
  		end
  	end
  end
  
  function Adv:wearArtifact(slot, id)
  	local advAFGet = self.owner:getProperty("advAFGet")
  	local advAFWear = self.owner:getProperty("advAFWear")
  

  	if id == -1 then
  		if not advAFWear[slot] then return end
  	else
  		if not advAFGet[id] then return end
  	end
  

  	local curWear = {}
  	for _, _id in pairs(advAFWear) do
  		curWear[_id] = 1
  	end
  	if curWear[id] then return end
  
  	if advAFWear[slot] then
  		local oldData = csvdb["adv_artifactCsv"][advAFWear[slot]][advAFGet[advAFWear[slot]]]
  		self:delArtifactEffect(oldData.effect)
  		if oldData.comboId ~= 0 then
  			local comboData = csvdb["adv_artifact_comboCsv"][oldData.comboId]
  			if comboData then
  				local isHaveCombo = true
  				for _, _id in ipairs(comboData.artifactid:toArray(true)) do
  					if not curWear[_id] then
  						isHaveCombo = false
  						break
  					end
  				end
  				if isHaveCombo then
  					self:delArtifactEffect(comboData.effect)
  				end
  			end
  		end
  		curWear[advAFWear[slot]] = nil
  	end
  	

  	if id ~= -1 then
  		curWear[id] = 1
  		local newData = csvdb["adv_artifactCsv"][id][advAFGet[id]]
  		self:addArtifactEffect(newData.effect)
  
  		if newData.comboId ~= 0 then
  			local comboData = csvdb["adv_artifact_comboCsv"][newData.comboId]
  			if comboData then
  				local isHaveCombo = true
  				for _, _id in ipairs(comboData.artifactid:toArray(true)) do
  					if not curWear[_id] then
  						isHaveCombo = false
  						break
  					end
  				end
  				if isHaveCombo then
  					self:addArtifactEffect(comboData.effect)

  				end

  			end
  		end

  	else
  		id = nil

  	end

  	self:log({desc = "wearArtifact", int1 = id})

  	self.owner:changeUpdates({{type = "advAFWear", field = slot, value = id}})
  	return true
  end
  

  -- 是否穿着指定神器
  function Adv:isWearAF(id)
  	local advAFWear = self.owner:getProperty("advAFWear")
  	for _, _id in pairs(advAFWear) do
  		if _id == id then
  			return true
  		end
  	end
  	return false
  end
  --是否激活指定神器套装
  function Adv:haveComboAF(id)
  	local advAFGet = self.owner:getProperty("advAFGet")
  	local advAFWear = self.owner:getProperty("advAFWear")
  	local curWear = {}
  	for _, _id in pairs(advAFWear) do
  		curWear[_id] = 1
  	end
  	for _, _id in pairs(advAFWear) do
  		local afData = csvdb["adv_artifactCsv"][_id][advAFGet[_id]]
  		if afData.comboId == id then
  			local comboData = csvdb["adv_artifact_comboCsv"][afData.comboId]
  			if comboData then
  				for _, _id2 in ipairs(comboData.artifactid:toArray(true)) do
  					if not curWear[_id2] then
  						return false
  					end
  				end
  				return true
  			end
  			return false
  		end
  	end
  	return false
  end
  

  function Adv:artifactLevelUp(id, level)
  	level = level or 1

  	local advAFGet = self.owner:getProperty("advAFGet")

  	if not advAFGet[id] then return end

  	local advAFWear = self.owner:getProperty("advAFWear")

  	local curWear = {}
  	for _, _id in pairs(advAFWear) do
  		curWear[_id] = 1
  	end

  	
  	local newLv = advAFGet[id]
  	for i = 1, level do
  		if not self.owner:isArtifactOpen(id, self:isEndless(), newLv + 1) then break end
  		newLv = newLv + 1
  	end
  	if newLv == advAFGet[id] then return end
  

  	self:log({desc = "artifactLevelUp", int1 = id, int2 = level})
  
  

  	local status = 0

  	if curWear[id] then -- 穿着呢

  		local oldData = csvdb["adv_artifactCsv"][id][advAFGet[id]]

  		local newData = csvdb["adv_artifactCsv"][id][newLv]

  		self:delArtifactEffect(oldData.effect)
  		self:addArtifactEffect(newData.effect)
  		status = 1
  	end

  	self.owner:changeUpdates({{type = "advAFGet", field = id, value = newLv}})
  	self:checkAchievement(Adv.AchievType.MWeaponLv, 1, id, newLv)

  	return status
  end
  
  function Adv:waitChooseArtifact()
  	local chooses = {}
  	local pool = {}
  	local count = 3  --需要多少个
  
  	for id, temp in pairs(csvdb["adv_artifactCsv"]) do
  		if not self:isHaveArtifact(id) and self.owner:isArtifactOpen(id, self:isEndless()) then
  			table.insert(pool, id)
  		end
  	end

  	if #pool == 0 then

  		self:award({[ItemId.AdvPoint] = 48}, {log = {desc = "chooseArtifact"}})

  	else
  		for i = 1, math.min(count, #pool) do

  			local idx = math.randomInt(1, #pool)
  			table.insert(chooses, pool[idx])
  			table.remove(pool, idx)
  		end

  		self.waitArtifact = chooses
  		self:backChooseArtifact()

  	end

  end
  
  function Adv:isWaitChooseArtifact()
  	return self.waitArtifact
  end
  
  function Adv:chooseArtifact(index)
  	if not self.waitArtifact or not self.waitArtifact[index] then return end

  	self:award({[self.waitArtifact[index]] = 1}, {log = {desc = "chooseArtifact"}})
  
  	self:log({desc = "chooseArtifact", int1 = self.waitArtifact[index]})
  

  	self.waitArtifact = nil

  
  	-- 支援效果继续选择
  	self:supportChooseArtifact()
  

  	return true
  end
  
  function Adv:isEndless()
  	return AdvCommon.isEndless(self.chapterId)
  end

  function Adv:getCurFloorData()

  	local chapter = self.chapterId % 100

  	return (csvdb["adv_chapter_floorCsv"][self.chapterId] or {})[self.level]

  end
  

  --关卡结束

  function Adv:over(success, rewardRatio, overType)

  	if success then 
  		rewardRatio = rewardRatio or 100

  		overType = overType or 0

  	else
  		rewardRatio = rewardRatio or globalCsv.adv_fail_reward_ratio

  		overType = overType or -1

  	end

  	local chapterData = csvdb["adv_chapterCsv"][self.chapterId]
  	-- 扣除的东西给积分

  	local addScore = 0

  	for itemId, count in pairs(self.owner:getProperty("advItems"):toNumMap()) do

  		local itemCsv = csvdb["itemCsv"][itemId]

  		if not itemCsv then
  			print("ERROR: no itemId in ItemCsv : ", itemId)
  		elseif itemCsv.type == ItemType.AdvItem then

  			addScore = addScore + count * itemCsv.advScore

  		end

  	end

  	self:scoreChange(AdvScoreType.ItemBack, addScore)
  
  	local score = self.owner:fixAdvScoreChange(self:getScore())
  	local scoreInfo = self.score
  	
  	local scoreReward = math.floor(score / chapterData.scoreAward)

  	self.owner:award({[ItemId.OldCoin] = scoreReward}, {log = {desc = "advOver", int1 = self.chapterId}})

  	-- 被动技会影响奖励

  	self.battle.player:triggerPassive(Passive.ADV_OVER, {score = score, level = self.level})
  

  	local reward = {}
  	for itemId, count in pairs(self.owner:getProperty("advItems"):toNumMap()) do
  		local itemCsv = csvdb["itemCsv"][itemId]
  		if not itemCsv then
  			print("ERROR: no itemId in ItemCsv : ", itemId)
  		elseif itemCsv.type ~= ItemType.AdvItem then
  			reward[itemId] = math.ceil(count * rewardRatio / 100)
  		end
  	end

  	reward = self.owner:award(reward, {log = {desc = "advOver", int1 = self.chapterId}})

  	if success then

  		self.owner:checkTaskEnter("AdvPass", {id = self.chapterId, level = self.level, score = score})

  		
  		if not self:isEndless() and self.level >= chapterData.limitlevel then

  			self.owner:checkTaskEnter("AdvAllPass", {id = self.chapterId})
  		end

  		local roleId = self.owner:getProperty("id")
  		local oldMaxScore = tonum(redisproxy:zscore(RANK_ADV, roleId))
  		if score > oldMaxScore then
  			local team = self.owner:getProperty("advTeam")
  			local curInfo = {
  				name = self.owner:getProperty("name"),
  				headId = self.owner:getProperty("headId"),
  				lv = self.owner:getProperty("level"),

  				batteV = self.owner:getTeamBattleValue(team.heros),

  				chapter = self.chapterId,
  				format = self.owner:getTeamHerosInfo(team.heros),
  			}
  			redisproxy:pipelining(function (red)
  				red:zadd(RANK_ADV, score, roleId)	--更新分数
  				red:hset(RANK_ADV_INFO, roleId,  MsgPack.pack(curInfo))
  			end)
  		end

  	end

  	self:clearAdvUnlockCache()

  
  	self:log({desc = "over", short1 = success and 1 or 0, int1 = overType})
  

  	self:clear()

  	self.owner:checkTaskEnter("AdvScore", {score = score})

  	self.owner:updateProperties({
  		advItems = "",
  		advAFGet = {},
  		advAFWear = {},
  	})

  	self:backEnd(success, score, scoreInfo, reward, overType, scoreReward)

  end