-- 角色
  local Buff = require "adv.AdvBuff"

  local Skill = require "adv.AdvSkill"

  local Passive = require "adv.AdvPassive"
  
  local BaseObject = class("BaseObject")
  function BaseObject:ctor(battle)
  	self.battle = battle
  	self.hpMax = 0
  	self.hp = 0
  	self.atk = 0

  	self.def = 0

  	self.aType = 0 --攻击类型
  	self.lock = nil
  	self.passives = {} --固有技能
  	self.buffs = {} --buff

  	self.skillOrder = {} --战斗内技能序列

  	self.isDead = false

  end
  --初始化角色
  function BaseObject:initData(data)
  	self.hpMax = data.hpMax or data.hp
  	self.hp = data.hp

  	--可变化的值
  	self.atk = data.atk
  	self.miss = data.miss
  	self.hit = data.hit

  	self.def = data.def

  	--基础值记录
  	self._atk = data._atk or self.atk
  	self._miss = data._miss or self.miss
  	self._hit = data._hit or self.hit

  	self._def = data._def or self.def

  	self._hpMax = data._hpMax or self.hpMax

  end
  -- 角色初始化完以后才是 技能和被动技能  方便初始化 buff 的 释放对象
  function BaseObject:initAfter(data)
  	for _, passive in ipairs(data.passives or {}) do

  		table.insert(self.passives, Passive.new(self, passive))

  	end
  	for _, buff in ipairs(data.buffs or {}) do
  		table.insert(self.buffs, Buff.load(self, buff))
  	end
  end
  

  function BaseObject:reset(data)
  	self.passives = {}
  	self.buffs = {}
  	self:initData(data)
  	self:initAfter(data)
  end
  

  function BaseObject:afterRound(roundType)
  	if roundType == "passive" then
  		for _, passive in ipairs(self.passives) do
  			passive:afterRound(self)
  		end

  	elseif roundType == "buffBefore" then

  		for _, buff in ipairs(self.buffs) do

  			if buff.buffData.intoEffect == 1 then
  				buff:afterRound()
  			end
  		end
  	elseif roundType == "buffAfter" then
  		for _, buff in ipairs(self.buffs) do
  			if buff.buffData.intoEffect == 0 then
  				buff:afterRound()
  			end

  		end

  	end
  end
  

  function BaseObject:clearRound()
  	for i = #self.passives, 1, -1 do
  		if self.passives[i].isDel then

  			table.remove(self.passives, i)
  		end
  	end
  	for i = #self.buffs, 1, -1 do
  		if self.buffs[i].isDel then

  			local buff = self.buffs[i]

  			table.remove(self.buffs, i)

  			buff:endBuff()
  			if self.attrChangeCondBuffCheck then
  				self:attrChangeCondBuffCheck(2, buff.id)
  			end

  		end
  	end
  end
  function BaseObject:clear()
  	self.buffs = {}
  	self.passives = {}

  	if self:is("Enemy") then
  		self.battle.player:attrChangeCondBuffCheck(3, self:getClassify())
  		for _, monster in pairs(self.battle.player:getTeam(2)) do
  			monster:attrChangeCondBuffCheck(3, self:getClassify())
  		end
  	end

  end
  

  function BaseObject:addPassive(params)
  	local skillId = params.id

  	local skillData = csvdb["adv_map_passiveCsv"][skillId]

  	if not skillData then return end
  	local level = params.level or 1
  	if not skillData[level] then return end

  
  	if self:getPassiveById(skillId) then return end -- 被动技不能重复
  

  	table.insert(self.passives, Passive.new(self, { id = skillId, level = level }))

  end
  

  function BaseObject:getPassiveById(bId)
  	for idx, passive in ipairs(self.passives) do
  		if passive.id == bId then
  			return passive
  		end
  	end
  end
  

  function BaseObject:getPassiveIdx(passive)
  	for idx, passive_ in ipairs(self.passives) do
  		if passive_ == passive then

  			if passive.passiveData.dispel ~= 1 then
  				return idx
  			end
  			return

  		end
  	end

  	return

  end
  
  function BaseObject:getDisablePassiveCount()

  	local count

  	for _, buff in ipairs(self.buffs) do

  		if not buff:isHide() and buff:getType() == Buff.DISABLE_BUFF then

  			if buff:effect() == 0 then
  				return 0
  			end
  			count = (count or 0) + buff:effect()

  		end
  	end

  	return count

  end
  

  function BaseObject:addBuff(buffId, releaser, layer)
  	layer = layer or 1

  	local buffData = csvdb["adv_map_buffCsv"][buffId]

  	if not buffData then return end
  	for _, buff in ipairs(self.buffs) do

  		if not buff:isHide() and (buff:getType() == Buff.CLEAR_BUFF or buff:getType() == Buff.IMMNUE_BUFF) then

  			if buff:canEffect(buffId) then

  				buff:effect()

  				return
  			end
  		end
  	end

  	local oldBuff = self:getBuffById(buffId)
  	if oldBuff then
  		if not oldBuff:checkKeep() then return end

  		oldBuff:overlay(releaser, {}, layer) -- 叠加

  	else
  		-- 不能保持的buff 也加不上去
  		if not Buff.checkKeep({
  			owner = self,
  			buffData = buffData,

  			releaseId = releaser and releaser.monsterId or nil

  		}) then return end

  		local buff = Buff.create(self, releaser, {id = buffId})
  		table.insert(self.buffs, buff)

  		buff:createAfter(layer)

  	end

  	self:triggerPassive(Passive.GET_BUFF, {trigger = releaser, buffId = buffId})
  	self:triggerPassive(Passive.PLAYER_BUFF_CLASSIFY, {trigger = releaser, classify = buffData.classify})

  	self:attrChangeCondBuffCheck(2, buffId)

  	return true

  end
  

  function BaseObject:getBuffById(bId)
  	for idx, buff in ipairs(self.buffs) do

  		if buff.id == bId and not buff:isHide() then

  			return buff
  		end
  	end
  end
  

  function BaseObject:delBuffById(bId)

  	for idx, buff in ipairs(self.buffs) do
  		if buff.id == bId then

  			table.remove(self.buffs, idx)

  			buff:endBuff()
  			if self.attrChangeCondBuffCheck then
  				self:attrChangeCondBuffCheck(2, bId)
  			end

  			return buff
  		end
  	end
  end
  
  function BaseObject:delPassiveById(pId)

  	for idx, passive in ipairs(self.passives) do
  		if passive.id == pId then

  			table.remove(self.passives, idx)

  			return passive
  		end
  	end
  end
  

  function BaseObject:hadBuff(bType)
  	for _, buff in ipairs(self.buffs) do

  		if not buff:isHide() and buff:getType() == bType then

  			return buff

  		end
  	end
  end
  

  function BaseObject:hadBuffById(bId)
  	for _, buff in ipairs(self.buffs) do

  		if not buff:isHide() and buff.id == bId then

  			return buff

  		end
  	end
  end
  

  function BaseObject:reSetSpMax()
  end
  

  function BaseObject:checkAuraBuff(buffs)
  end
  
  function BaseObject:getAuras()
  	local auras = {}
  	if self:is("Enemy") then
  		local halo = csvdb["event_monsterCsv"][self.monsterId].halo
  		if halo then
  			for _, one in ipairs(halo:toArray(true, "=")) do
  				table.insert(auras, one)
  			end
  		end
  	elseif self:is("Build") then
  		local halo = csvdb["event_buildingCsv"][self.id].halo
  		if halo then
  			for _, one in ipairs(halo:toArray(true, "=")) do
  				table.insert(auras, one)
  			end
  		end
  	end 
  
  	return auras
  end
  

  -- 通用的buff 效果汇总  -- 0 固定 1百分比  两种分类

  function BaseObject:getCommonBuffEffect(bType, otherCond)

  	local effect, count = {[0] = 0, [1] = 0}, 0
  	for _, buff in ipairs(self.buffs) do

  		if not buff:isHide() and buff:getType() == bType then

  			local cType, value, cond = buff:effect()
  			if cType and (not otherCond or otherCond == cond) then

  				effect[cType] = effect[cType] + value

  				count = count + 1
  			end
  		end
  	end

  	effect[1] = effect[1] / 100

  	return effect, count --效果 和生效的buff 个数
  end
  --伤害反弹

  function BaseObject:getBackHurtBuff()

  	local effect = {[0] = 0, [1] = 0}
  	for _, buff in ipairs(self.buffs) do

  		if not buff:isHide() and buff:getType() == Buff.BACK_HURT then

  			local cType, value = buff:effect()  --  aType 0 全部  1 普通攻击

  			if cType then

  				effect[cType] = effect[cType] + value

  			end
  		end
  	end
  	return effect
  end
  
  --释放者伤害变化
  function BaseObject:getHurtChange()
  	local change = self:getCommonBuffEffect(Buff.HURT_CHANGE)
  	return change
  end
  --受伤者受伤变化
  function BaseObject:getInjuredChange()
  	local change = self:getCommonBuffEffect(Buff.INJURED_CHANGE)
  	return change
  end

  -- 奖励道具变化
  function BaseObject:getRewardChange(itemId)
  	local change = self:getCommonBuffEffect(Buff.ITEM_GET_UP, itemId)
  	return change
  end
  
  -- buff 增益 检疫
  function BaseObject:getBuffEffectChange(classify)

  	local classifys = classify:toArray(true, " ")
  	local had = {}
  	for _, one in pairs(classifys) do
  		had[one] = 1
  	end

  	local effect = 0
  	for _, buff in ipairs(self.buffs) do

  		if not buff:isHide() and buff:getType() == Buff.Buff_EFFECT_CHANGE then

  			local cType, value = buff:effect()

  			if cType and had[cType] then

  				effect = effect + value
  			end
  		end
  	end
  	effect = effect / 100
  	return effect
  end
  
  function BaseObject:getAttrBuffChange(attr)
  	local AttrBuff = {
  		[Buff.ATTR_CHANGE] = 1,
  		[Buff.ATTR_CHANGE_COND] = 1,
  	}
  	local effect, count = {[0] = 0, [1] = 0}, 0
  	for _, buff in ipairs(self.buffs) do

  		if not buff:isHide() and AttrBuff[buff:getType()] then

  			local cType, value, attrName = buff:effect()
  			if cType and attr == attrName then
  				effect[cType] = effect[cType] + value
  				count = count + 1
  			end
  		end
  	end
  	effect[1] = effect[1] / 100
  	return effect, count
  end

  --重新计算属性
  function BaseObject:reSetAttr(field)

  	local old = self[field]

  	self[field] = self["_" .. field] --重置一下

  	local effect = self:getAttrBuffChange(field)

  	self[field] = math.ceil((self[field] + effect[0]) * (1 + effect[1]))

  	local delta = self[field] - old

  end
  

  -- 重新计算 血量上限
  function BaseObject:reSetHpMax()
  	self.hpMax = self._hpMax
  	for _, buff in ipairs(self.buffs) do

  		if not buff:isHide() and buff:getType() == Buff.HP_MAX_CHANGE then

  			local cv = buff:effect()
  			if cv then
  				self.hpMax = self.hpMax + cv
  			end
  		end
  	end

  	local effect = self:getAttrBuffChange("hp")

  	self.hpMax = (self.hpMax + effect[0]) * (1 + effect[1])

  	self.hpMax = math.ceil(math.max(1, self.hpMax))

  	self.hp = math.min(self.hpMax, self.hp)
  end
  

  --计算打出伤害加成后的值 
  function BaseObject:getHurtValue(value)
  	value = value or self.atk
  	local hurtChange = self:getHurtChange()
  	return math.max(0, (value + hurtChange[0]) * (1 + hurtChange[1]))
  end
  --计算自己伤害减免后的值
  function BaseObject:getInjuredValue(value)
  	local injuredChange = self:getInjuredChange()

  	return math.max(0, (value + injuredChange[0]) * (1 + injuredChange[1]))

  end
  

  --最终伤害 = [ (敌方攻击 - 己方防御) * （1+伤害增加百分比-伤害减少百分比）*（1+受伤增加百分比-受伤减少百分比）+（伤害增加固定值-伤害增加固定值+受伤增加固定值-受伤增加固定值）]*（1+侍宠百分比）-侍宠固定值

  -- params   -- hurtType  1 普攻伤害  2 buff伤害  3 反弹伤害  4 真实伤害  5 客户端发回来的伤害  --直接作用 6 buff伤害（真实）

  --进入这个方法之前计算好释放者加成的伤害
  function BaseObject:hurt(value, releaser, params)
  	params = params or {}

  
  	if params.hurtType and (params.hurtType == 2 or params.hurtType == 6) then
  		self:triggerPassive(Passive.SELF_HURT, {trigger = releaser, buffId = params.buffId})

  		for _, team in ipairs(self:getTeam(1, true)) do

  			team:triggerPassive(Passive.TEAM_HURT, {trigger = releaser, buffId = params.buffId})

  		end

  	end

  	if params.hurtType ~= 5 then

  		if params.hurtType ~= 6 and params.hurtType ~= 4 then

  			value = math.max(0, value - self.def)

  		end

  		value = self:getInjuredValue(value) --减伤计算

  		if value == 0 then return end
  
  		-- 舍身和恃宠
  		local team = self:getTeam(1)
  		local transfer = {}
  		local absorb = {}
  		for _, one in ipairs(team) do
  			local change1, count1 = one:getCommonBuffEffect(Buff.INJURED_CHANGE)
  			local change2, count2 = one:getCommonBuffEffect(Buff.HURT_ABSORB)
  			if count1 > 0 then
  				table.insert(transfer, {one, change1, count1})
  			end
  			if count2 > 0 then
  				table.insert(absorb, {one, change2, count2})
  			end

  		end

  		if #absorb == 1 then --舍身优先级高  --舍身生效
  			if absorb[1][1] ~= self then --舍身的人不是自己才有效
  				local absorbV = (value - absorb[1][2][0]) * absorb[1][2][1] + absorb[1][2][0]  --固定值先生效
  				value = value - absorbV
  				absorb[1][1]:hurt(absorbV, releaser, params)
  			end
  		else
  			if #transfer == 1 and transfer[1][1] == self and #team > 1 then --侍宠 生效  
  				local transferValue = (value - transfer[1][2][0])* transfer[1][2][1] + transfer[1][2][0] --固定值先生效
  				value = value - transferValue
  				local oneValue = transferValue / (#team - 1)
  				for _, one in ipairs(team) do
  					if one ~= self then
  						one:hurt(oneValue, releaser, params)
  					end

  				end
  			end
  		end
  	end
  

  	value = math.max(0, math.ceil(value))

  	if value == 0 then return end
  	-- 反弹伤害

  	if params.hurtType ~= 3 and params.hurtType ~= 5 and releaser and not releaser.isDead then

  		local backEffect = self:getBackHurtBuff()

  		local backValue = math.max(0, value * backEffect[1] + backEffect[0])
  		releaser:hurt(backValue, releaser, {hurtType = 3})
  	end
  
  	--受伤了~

  	if self:is("Player") and params.hurtType ~= 5 then
  		self.battle.adv:pushBackEvent(AdvBackEventType.HpChange, {change = -value})
  	end
  

  	if params.hurtType ~= 5 then -- 非客户端发回的伤害  返回更新地块
  		if self.roomId and self.blockId then
  			self.battle.adv:backBlockChange(self.roomId, self.blockId)
  		end
  	end

  	self.hp = math.max(0, self.hp - value)

  	if self.hp == 0 then

  		self:triggerPassive(Passive.SELF_DEAD)
  		for _, team in ipairs(self:getTeam(1, true)) do

  			team:triggerPassive(Passive.TEAM_DEAD, {trigger = self})

  		end
  

  		if (params.hurtType == 6 or params.hurtType == 2) and self ~= self.battle.player then

  			self.battle.adv:checkAchievement(self.battle.adv.AchievType.KillByBuff, 1, params.buffId)
  		end

  		self.isDead = true

  	end

  	self:triggerPassive(Passive.HURT_PERCENT_SELF, {value = value / self.hpMax})
  	for _, team in ipairs(self:getTeam(1, true)) do
  		team:triggerPassive(Passive.HURT_PERCENT_TEAM, {value = value / self.hpMax})
  	end

  end
  --恢复
  function BaseObject:recover(value, releaser, params)
  	params = params or {}

  	value = math.max(0, math.ceil(value))

  	local old = self.hp

  	self.hp = math.min(self.hpMax, self.hp + value)

  	local change = self.hp - old

  	if self:is("Player") then

  		if change > 0 then
  			self.battle.adv:pushBackEvent(AdvBackEventType.HpChange, {change = value})
  		end

  	end

  end
  

  function BaseObject:addSpecialSkill(skillId, skillLevel, target)
  	local skillData = {id = skillId, level = skillLevel, target = target}
  	table.insert(self.skillOrder, skillData)
  end
  

  function BaseObject:releaseSkill(skillId, target)

  	if self:hadBuff(Buff.CANT_SKILL) then return end -- 针对 怪物

  	local skill = Skill.new(self, {id = skillId, target = target})

  	--返回客户端

  	for _, target in ipairs(skill:getTargets()) do

  		self.battle.adv:backSkill(self.monsterId, skillId, target.id)

  	end

  	skill:doEffect()

  	for _, team in ipairs(self:getTeam(2)) do
  		team:triggerPassive(Passive.TARGET_SKILL)
  	end
  	for _, team in ipairs(self:getTeam(1, true)) do
  		team:triggerPassive(Passive.TEAM_SKILL)
  	end

  end
  
  --0 全部  1 我方  2 敌方

  function BaseObject:getTeam(nType, noSelf, mapIdx, includeLock)

  	mapIdx = mapIdx or self.battle.adv:getCurMapIdx()

  	nType = nType or 0
  	local team = {}
  	local function addPlayer()
  		if not noSelf or self.battle.player ~= self then
  			if not self.battle.player.isDead then
  				table.insert(team, self.battle.player)
  			end
  		end
  	end
  	local function addEnemy()

  		for _, enemy in pairs(self.battle.enemys[mapIdx]) do

  			if not noSelf or enemy ~= self then 

  				if not enemy.isDead and (includeLock or not enemy.lock) then -- 已经翻开的

  					table.insert(team, enemy)
  				end
  			end
  		end
  	end
  	if nType == 0 then
  		addPlayer()
  		addEnemy()
  	elseif nType == 1 then

  		if not self.monsterId then --玩家

  			addPlayer()
  		else
  			addEnemy()
  		end
  	elseif nType == 2 then

  		if not self.monsterId then --玩家

  			addEnemy()
  		else
  			addPlayer()
  		end
  	end
  	return team
  end
  

  function BaseObject:attrChangeCondBuffCheck(etype, cond)
  	local effect = {}
  	if etype == 3 then
  		if type(cond) ~= "string" then
  			return
  		end
  		local temp = cond:toArray(true, " ")
  		cond = {}
  		for _, one in pairs(temp) do
  			cond[one] = 1
  		end
  	elseif etype == 4 then
  		if not cond then
  			cond = {}
  		end
  		if type(cond) == "number" then
  			cond = {[cond] = 1}
  		end
  	end
  	for _, buff in ipairs(self.buffs) do
  		if not buff:isHide() and (buff:getType() == Buff.ATTR_CHANGE_COND) then
  			local _et, _attr, _co = buff:getEffectBy()
  			if etype == _et then
  				if etype == 3 or etype == 4 then
  					if cond[_co] then
  						effect[_attr] = 1
  					end
  				else
  					if (not _co or _co == cond) then
  						effect[_attr] = 1
  					end
  				end
  			end
  		end
  	end
  	for attrName, _ in pairs(effect) do
  		if attrName == "hp" then
  			self:reSetHpMax()
  		else
  			self:reSetAttr(attrName)
  		end
  	end
  end
  

  function BaseObject:getDB()
  	local db = {}

  	db.hp = self.hp

  	local baseAttr = {"atk", "miss", "hit", "def", "hpMax"}

  	for _, field in pairs(baseAttr) do
  		db[field] = self[field]
  		db["_"..field] = self["_" .. field]
  	end
  	db.passives = {}
  	for _, passive in ipairs(self.passives) do
  		table.insert(db.passives, passive:getDB())
  	end

  	db.buffs = {}

  	for _, buff in ipairs(self.buffs) do
  		table.insert(db.buffs, buff:getDB())
  	end
  	return db
  end
  
  function BaseObject:triggerPassive(condType, params)

  	if self.isDead then return end
  	for _, passive in ipairs(self.passives) do
  		passive:trigger(condType, params) --检查触发
  	end

  end
  

  function BaseObject:changeSp()
  end
  

  function BaseObject:is(what)
  	return self["is" .. what] and self["is" .. what](self)
  end
  

  local Enemy = class("Enemy", BaseObject)

  function Enemy:ctor(battle, mId, monsterId, roomId, blockId, lock, enemy, mapIdx)

  	Enemy.super.ctor(self, battle)

  	self.id = mId
  	self.monsterId = monsterId  --数据id

  	self.roomId = roomId
  	self.blockId = blockId
  	self.lock = lock

  	self.mapIdx = mapIdx

  	self:initData(enemy)
  end

  function Enemy:unlock()

  	self.lock = nil
  end
  

  function Enemy:isEnemy()
  	return true
  end
  

  function Enemy:getObstacle()
  	local obstacle = csvdb["event_monsterCsv"][self.monsterId].obstacle
  	if obstacle == 0 and self:hadBuff(Buff.OBSTACLE_CHANGE) then
  		obstacle = 1
  	end
  	return obstacle
  end
  

  function Enemy:isClassify(check)
  	local classify = self:getClassify()
  	return classify and classify:sismember(check, " ")
  end
  
  function Enemy:getClassify()
  	return csvdb["event_monsterCsv"][self.monsterId].classify
  end
  

  -- 0=所有  1=怪物  2=玩家
  function Enemy:checkAuraBuff(buffs)
  	local needBuffs = {}
  
  	for buffId, info in pairs(buffs[0] or {}) do
  		needBuffs[buffId] = needBuffs[buffId] or {}
  		needBuffs[buffId].count = (needBuffs[buffId].count or 0) + info.count
  		needBuffs[buffId].exist = info.exist
  	end
  
  	for buffId, info in pairs(buffs[1] or {}) do
  		needBuffs[buffId] = needBuffs[buffId] or {}
  		needBuffs[buffId].count = (needBuffs[buffId].count or 0) + info.count
  		needBuffs[buffId].exist = info.exist
  	end
  
  	for buffId, info in pairs(needBuffs) do
  		if info.count < 0 then
  			local buff = self:getBuffById(buffId)
  			if buff then
  				buff:uncover(info.exist and -info.count or -1, true)
  			end
  		elseif count > 0 then
  			self:addBuff(buffId, nil, info.count)
  		end
  	end
  end

  function Enemy:kill()
  	self:hurt(self.hp, self.battle.player, {hurtType = 5})
  end
  

  local Player = class("Player", BaseObject)
  function Player:ctor(battle, data)
  	Player.super.ctor(self, battle)
  	self:initData(data)
  end
  

  function Player:initData(data)
  	Player.super.initData(self, data)

  	-- self.level = data.level or 1  --level 每增加1级  属性增长 growth * baseAttr

  	self.growth = data.growth

  	-- self.exp = data.exp or 0

  	self.sp = data.sp or 100

  	self.spMax = data.spMax or 100
  	self._spMax = data._spMax or 100

  end
  

  -- function Player:addExp(value)
  -- 	-- buff 经验加成
  -- 	local up = self:getCommonBuffEffect(Buff.EXP_UP)
  -- 	value = math.ceil((value + up[0]) * (1 + up[1]))
  
  -- 	if value <= 0 then return end
  -- 	local newExp = self.exp + value
  -- 	local level = self.level
  -- 	if level >= #csvdb["adv_levelCsv"] then return end
  -- 	while true do
  -- 		local curData = csvdb["adv_levelCsv"][level]
  -- 		if newExp < curData.exp then break end
  -- 		level = level + 1
  -- 		newExp = newExp - curData.exp
  -- 		if level >= #csvdb["adv_levelCsv"] then break end
  -- 	end
  -- 	local delta = level - self.level
  
  -- 	self.battle.adv:pushBackEvent(AdvBackEventType.Exp, {delta = value})
  
  -- 	if delta > 0 then
  -- 		for attr, _ in pairs(AdvAttsEnum) do
  -- 			self:addBaseAttr(attr, self.growth[attr] * delta, 0, true)
  -- 		end
  -- 		self.battle.adv:pushBackEvent(AdvBackEventType.Level, {level = level, delta = delta})
  -- 	end
  -- 	self.level = level
  -- 	self.exp = newExp
  -- 	return value
  -- end

  --vtype 0/1 值/%

  function Player:addBaseAttr(attr, value, vtype, ignoreBack)

  	local attrName = attr
  	if attr == "hp" then
  		attrName = "hpMax"