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:mylog(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:mylog("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.logid = advInfo.logid or "auto"

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

  	end

  	self:initBattle(advInfo)

  end

  -- 找出level 是否存在中继层

  function Adv:isHaveRelay(level, chapterId, force)

  	level = level or self.level

  	chapterId = chapterId or self.chapterId

  	if level == 1 and not force 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(params)
  	local chapterId = params.chapterId
  	local level = params.level 
  	local isToNext = params.isToNext 
  	local notNotify = params.notNotify 
  	local isRelay = params.isRelay 
  	local isEnter = params.isEnter 
  	local support = params.support
  	local debugMapId = params.debugMapId
  

  	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 {}

  	if self.battle then
  		self.battle:overBattle()
  	end

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

  	self.logid = self.owner:getActionUcode()

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

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

  	end

  	-- 随机出地图

  	local mapId, relayData

  
  	if debugMapId and csvdb["mapCsv"][debugMapId] then
  		mapId = debugMapId
  	end
  	if not mapId then
  		if isRelay then
  			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

  	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

  		end
  	end

  	self.maps = {}

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

  	self:initBattle(nil, isToNext)

  	self:initLayerTask()
  

  	self:checkTask(Adv.TaskType.Arrive)

  	self:checkAdvUnlock(1, self.level)

  	-- 中继进入奖励

  	if relayData and isEnter then

  		self:awardRelay(relayData, notNotify)
  	end
  

  	if not notNotify then
  		self:saveDB(notNotify)

  	end

  end

  function Adv:passAdvRelay()
  	local advRelay = self.owner:getProperty("advRelay")
  	local chapter = self:isEndless() and -1 or self.chapterId
  	if not (advRelay[chapter] or {})[self.level] then
  		advRelay[chapter] = advRelay[chapter] or {}
  		advRelay[chapter][self.level] = 1
  		self.owner:updateProperty({field = "advRelay", value = advRelay})
  		local relayData = self:isHaveRelay()
  		if relayData and relayData.award ~= "" then
  			self:pushBackEvent(AdvBackEventType.RelayReward, {items = self:award(relayData.award:toNumMap(), {log = {desc = "relayReward"}})})
  		end
  	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.logid = self.logid

  		advInfo.maps = {}

  		self.battle:saveDB(advInfo)

  		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:awardRelay(relayData, notNotify)
  	local gift = {}
  
  	if relayData.artifact > 0 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(relayData.artifact, #pool) do
  			local idx = math.randomInt(1, #pool)
  			gift[pool[idx]] = 1
  			table.remove(pool, idx)
  		end
  	end
  
  	if relayData.point > 0 then
  		gift[ItemId.AdvPoint] = relayData.point
  	end
  
  	if relayData.otherAward ~= "" then
  		for dropId, count in pairs(relayData.otherAward:toNumMap()) do
  			for i = 1, count do
  				local dropData = csvdb["event_dropCsv"][dropId]
  				if dropData then
  					local item = dropData["range"]:randWeight(true)
  					gift[item[1]] = (gift[item[1]] or 0) + item[2]
  				else
  					skynet.error(string.format("[ERROR]: event_dropCsv no id %s,  adv_chapter_campsite",  dropId))
  				end
  			end
  		end
  	end
  
  	self:award(gift, {notNotify = notNotify,  log = {desc = "relayEnter", int1 = self.chapterId, int2 = self.level}})
  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}, notNotify = notNotify})

  		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(info, isToNext)

  	self.battle = require("adv.AdvBattle").new(self)

  	-- 支援效果生效一些
  	self:activeSomeSupport()
  	
  	-- 不是中继层  加上 层 和 地图的buff和被动
  	if not self.isRelay then
  		self.battle:initMapEffect()
  	end
  
  	if isToNext then
  		self.battle.player:afterLayer() -- 玩家的buff 清理一下
  	end
  

  	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 not info and isToNext then

  		self.battle.player:attrChangeCondBuffCheck(1)
  	end

  
  	-- 初始化

  	if not info then

  		self.battle:newBattle()

  	else
  		self.battle:loadBattle(info)

  	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:mylog("in_artifact", log)
  	else
  		print("awardArtifact no log ", debug.traceback())
  	end

  	if not params.isChoose then
  		self:pushBackEvent(AdvBackEventType.Artifact, {id = id})
  	end

  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:mylog({desc = "wearArtifact", int1 = id})

  	self.owner:log("mission_pick_equip", {
  		mission_threadid = self.chapterId, -- 大地图ID
  		mission_threadname = (csvdb["adv_chapterCsv"][self.chapterId] or {})["chapter"] or "auto", -- 大地图名称
  		mission_id = self.level, -- 关卡ID
  		mission_pick_equip_type = 1, --神器操作类型：1:装备，2:卸下
  		mission_pick_equip_id = id, --神器ID
  		mission_pick_equip_lv = advAFGet[id], --神器等级
  		mission_sequenceid = self.logid, -- 本次拾荒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:mylog({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"}, isChoose = true})

  	self:mylog({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)