local extension=Package("kuanglang")
local T = require "packages/jbs/record/Theorem"
local pvetool = require "packages/jbs/record/PVETool"
extension.extensionName="jbs"

Fk:loadTranslationTable{
    ["kuanglang"]="GBS-狂浪",
    
    
}

local jbs_kl_gulong=General:new(extension,"jbs_kl_gulong","wei",3)--顾龙p1
local jbs_kl_liutang=General:new(extension,"jbs_kl_liutang","wu",8)--刘唐奖励牌
local jbs_kl_menghuo=General:new(extension,"jbs_kl_menghuo","shu",4)--孟获-p1
local jbs_kl_baluoka=General:new(extension,"jbs_kl_baluoka","wei",3)--巴洛卡p1

local jbs_kl_shengwujiang=General:new(extension,"jbs_kl_shengwujiang","wu",8)--圣物匠p1-3
local jbs_kl_yuanshao=General:new(extension,"jbs_kl_yuanshao","qun",3)--袁绍p2
local jbs_kl_lvmeng=General:new(extension,"jbs_kl_lvmeng","wu",4)--吕蒙p2
local jbs_kl_yuanshen1=General:new(extension,"jbs_kl_yuanshen1","qun",1)--原神1p2
local jbs_kl_changyou=General:new(extension,"jbs_kl_changyou","wu",3)--长右p2
local jbs_kl_machao=General:new(extension,"jbs_kl_machao","shu",3,4)--马超p2
local jbs_kl_xuebeng=General:new(extension,"jbs_kl_xuebeng","wei",1)--雪崩p2

local jbs_kl_tianfa=General:new(extension,"jbs_kl_tianfa","wu",4)--天罚p3
local jbs_kl_daqiao=General:new(extension,"jbs_kl_daqiao","wu",5,5,General.Female)--大乔p3
local jbs_kl_lvbu=General:new(extension,"jbs_kl_lvbu","qun",5)--吕布p3
local jbs_kl_yanliangwenchou=General:new(extension,"jbs_kl_yanliangwenchou","qun",4)--颜良文丑p3
local jbs_kl_juexingzhe=General:new(extension,"jbs_kl_juexingzhe","wei",4)--觉醒者p3
local jbs_kl_ygsl=General:new(extension,"jbs_kl_ygsl","qun",4)--尤格萨隆p3
local jbs_kl_caocao=General:new(extension,"jbs_kl_caocao","wei",3)--拉法姆曹操p3
local jbs_kl_aoding=General:new(extension,"jbs_kl_aoding","shu",4)--奥丁
local jbs_kl_haila=General:new(extension,"jbs_kl_haila","wei",3)--海拉p1

local jbs_kl_sjtunshizhe=General:new(extension,"jbs_kl_sjtunshizhe","qun",7)--时间吞噬者p4
local jbs_kl_gufu=General:new(extension,"jbs_kl_gufu","wu",5)--古夫p4
local jbs_kl_yuanshen=General:new(extension,"jbs_kl_yuanshen","qun",7,7,General.Female)--原神p4
local jbs_kl_shengwujiangl=General:new(extension,"jbs_kl_shengwujianglast","wu",8)--圣物匠p4
local jbs_kl_peitefede=General:new(extension,"jbs_kl_peitefeide","shu",8)--团长p4
local jbs_kl_keli=General:new(extension,"jbs_kl_keli","shu",1)--可莉p4
local jbs_kl_kazhakusi=General:new(extension,"jbs_kl_kazhakusi","shu",4)--卡扎库斯p3
local jbs_kl_sagelasi=General:new(extension,"jbs_kl_sagelasi","shu",9)--萨格拉斯p4

-------

T.addpicpaths({jbs_kl_menghuo,jbs_kl_xuebeng,jbs_kl_gulong,jbs_kl_liutang,jbs_kl_baluoka,jbs_kl_shengwujiang
,jbs_kl_yuanshao,jbs_kl_lvmeng,jbs_kl_yuanshen1,jbs_kl_changyou,jbs_kl_machao,jbs_kl_xuebeng,jbs_kl_tianfa,jbs_kl_daqiao
,jbs_kl_lvbu,jbs_kl_yanliangwenchou,jbs_kl_juexingzhe,jbs_kl_ygsl,jbs_kl_caocao,jbs_kl_aoding,jbs_kl_haila,jbs_kl_sjtunshizhe,
jbs_kl_gufu,jbs_kl_yuanshen,jbs_kl_shengwujiangl,jbs_kl_peitefede,jbs_kl_keli,jbs_kl_kazhakusi,jbs_kl_sagelasi},"boss/")


--图片路径

jbs_kl_menghuo.hidden = true
jbs_kl_liutang.hidden = true
jbs_kl_haila.hidden = true
jbs_kl_shengwujiang.hidden = true
jbs_kl_gulong.hidden = true
jbs_kl_baluoka.hidden = true
jbs_kl_yuanshao.hidden = true
jbs_kl_yuanshen1.hidden = true
jbs_kl_tianfa.hidden = true
jbs_kl_changyou.hidden = true
jbs_kl_machao.hidden = true
jbs_kl_caocao.hidden = true
jbs_kl_daqiao.hidden = true
jbs_kl_lvbu.hidden = true
jbs_kl_yanliangwenchou.hidden = true
jbs_kl_peitefede.hidden = true
jbs_kl_juexingzhe.hidden = true
jbs_kl_xuebeng.hidden = true
jbs_kl_sjtunshizhe.hidden = true
jbs_kl_gufu.hidden = true
jbs_kl_yuanshen.hidden = true
jbs_kl_shengwujiangl.hidden = true
jbs_kl_ygsl.hidden = true
jbs_kl_keli.hidden = true
jbs_kl_kazhakusi.hidden = true
jbs_kl_sagelasi.hidden = true
jbs_kl_aoding.hidden = true
jbs_kl_lvmeng.hidden = true

---------------------



jbs_kl_peitefede.shield=5
jbs_kl_aoding.shield=2
----------------------------








--镇魂

local zhenhun = fk.CreateTriggerSkill{
    name = "jbskl__zhenhun",
    anim_type = "defensive",
    frequency = Skill.Compulsory,
    events = {fk.EventPhaseStart},
    can_trigger = function(self, event, target, player, data)
      if not player:hasSkill(self.name) then return false end
    return target == player and player.phase == Player.Finish
    end,
  
    on_use = function(self, event, target, player, data)
        local room=player.room
        room:addPlayerMark(player,"@jbskl_zhenhun",1)
        if player:getMark("@jbskl_zhenhun") > 4 then
            room:setPlayerMark(player,"@jbskl_zhenhun",0)

            for _, p in ipairs(room:getOtherPlayers(player, true)) do
                if not p.dead then
                    room:killPlayer{
                        who=p.id,
                        }
                end
            end
        end
    end,
  
  
}

--计时

local jishi= fk.CreateTriggerSkill{
    name = "jbskl__jishi",
    mute=true,
    frequency = Skill.Compulsory,
    events = {fk.CardUsing, fk.CardResponding},
    can_trigger = function(self, event, target, player, data)
      return target ~= player and player:hasSkill(self.name) and data.card
    end,
    on_use = function(self, event, target, player, data)
        local room=player.room
        room:addPlayerMark(player,"@jbskl__jishi",1)
        local n =player:getMark("@jbskl__jishi")
        if n>=8 then
          room:setPlayerMark(player,"@jbskl__jishi",0)
            room:damage{
                from = player,
                to = target,
                damage =2 ,
                damageType = fk.ThunderDamage,
                skillName = self.name,
              
            }

          if player.phase == Player.NotActive then

            room.logic:breakTurn()
          end

        end
    end,
  }


--蛮王

local manwang = fk.CreateTriggerSkill{
    name = "jbskl__manwang",
    anim_type = "offensive",
    frequency = Skill.Compulsory,
    events = {fk.EventPhaseStart},
    can_trigger = function(self, event, target, player, data)
      return target == player and player:hasSkill(self.name) and
        player.phase == Player.Play
    end,
    on_use = function(self, event, target, player, data)
      local room = player.room
      local card = Fk:cloneCard("savage_assault")
      card.skillName = self.name
      local n= player.maxHp-player.hp
      for i=1, n do
        if player.dead then break end
        room:useCard({
         from = player.id,
        card = card,
        })
      end
    end
  }

--名门

  local mingmen = fk.CreateTriggerSkill{
    name = "jbskl__mingmen",
    anim_type = "offensive",
    frequency = Skill.Compulsory,
    events = {fk.EventPhaseStart},
    can_trigger = function(self, event, target, player, data)
      return target == player and player:hasSkill(self.name) and
        player.phase == Player.Play
    end,
    on_use = function(self, event, target, player, data)
      local room = player.room
      local card = Fk:cloneCard("archery_attack")
      card.skillName = self.name
      local n=1+ player.maxHp-player.hp
      for i=1, n do
        if player.dead then break end
        room:useCard({
         from = player.id,
        card = card,
        })
      end
    end
  }

--绝色
local juese = fk.CreateTriggerSkill{
    name = "jbskl__juese",
    anim_type = "defensive",
    frequency = Skill.Compulsory,
    events = {fk.EventPhaseStart},
    can_trigger = function(self, event, target, player, data)
      if not player:hasSkill(self.name) then return false end
    return target == player and player.phase == Player.Finish
    end,
  
    on_use = function(self, event, target, player, data)
        local room=player.room
        local targets = table.map(room:getOtherPlayers(player), function(p) return p.id end)
        local tos = room:askForChoosePlayers(player, targets, 1, 1, "#jbs__kuanglang_attack-choose", self.name, false)
        local to
        if #tos > 0 then
        
          to = room:getPlayerById(table.random(targets))
        end
        room:damage{
            from = player,
            to = to,
            damage = 1,
            damageType = fk.FireDamage,
            skillName = self.name,
          
        }
    end,
  
  
}


--审判
local shenpan = fk.CreateTriggerSkill{
  name = "jbskl__shenpan",
  frequency = Skill.Compulsory,
  events = {fk.EventPhaseStart},
  can_trigger = function(self, event, target, player, data)
    if not player:hasSkill(self.name) then return false end
  return target == player and player.phase == Player.Start
  end,

  on_use = function(self, event, target, player, data)
      local room=player.room
      local pps=table.filter(room:getOtherPlayers(player), function(p) return true end)
      local targets = table.map(pps, function(p) return p.id end)
      local tos = room:askForChoosePlayers(player, targets, 1, 1, "#jbs__kuanglang_attack-choose", self.name, false)
      local tgt
      if #tos > 0 then
        tgt = room:getPlayerById(tos[1])
      else
        tgt = room:getPlayerById(table.random(targets))
      end
      local number=1
        while true do
        
          local judge = {
            who = tgt,
            reason = self.name,
            pattern = ".|.|spade,club",
          }
          room:judge(judge)
          if judge.card.color ~= Card.Black then
            number=number+1
          else 
            for i=1,number do
              if player.dead  then
                break
              end
              room:damage{
                from = player,
                to = tgt,
                damage =1,
                skillName = self.name,
              }
            end
            break
          end
          if player.dead  then
            break
          end
        end
  end,


}

--命运

local mingyun= fk.CreateTriggerSkill{
  name = "jbskl__mingyun",
  anim_type = "support",
  events = {fk.EventPhaseStart},
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
      return player:hasSkill(self.name) and player:getMark("mingyunboss-round") == 0 and player.phase == Player.Finish
  end,
  on_use = function(self, event, target, player, data)
    player.room:setPlayerMark(player,"mingyunboss-round",1)
    player:gainAnExtraTurn()
    
  end,
}

--成长
local chengzhang = fk.CreateTriggerSkill{
  name = "jbskl__chengzhang",
  anim_type = "defensive",
  frequency = Skill.Compulsory,
  events = {fk.AskForPeaches},
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self.name) and player.dying and player:usedSkillTimes(self.name, Player.HistoryGame) <2
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    player:throwAllCards("hej")
    if player.dead then return end
    if not player.faceup then
      player:turnOver()
    end
    if player.chained then
      player:setChainState(false)
    end
    if player.dead or not player:isWounded() then return end
    room:changeMaxHp(player, 3)
    room:recover({
      who = player,
      num = player.maxHp- player.hp,
      recoverBy = player,
      skillName = self.name,
    })
    player:drawCards(player.maxHp, self.name)
    local x=player:usedSkillTimes(self.name, Player.HistoryGame)
    local skill1=table.random({"jbs__diandeng","jbskl__mingyun"},1)
    local skill2=table.random({"jbskl__shenpan","jbskl__jishi"},1)
    if x==1 then
      room:handleAddLoseSkills(player, skill1[1], nil, false)

    elseif x==2 then
      room:handleAddLoseSkills(player, skill2[1], nil, false)

    end
    room.logic:breakTurn()
  end,
}

--堕魂

local duohun=fk.CreateTriggerSkill{
  name = "jbskl__duohun",
  anim_type = "support",
  events = {fk.DamageInflicted,fk.DamageCaused,fk.Damaged,fk.DrawNCards},
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
      if not player:hasSkill(self.name) then return false end
      return target==player
  end,
  on_use = function(self, event, target, player, data)
  local room=player.room
  if event==fk.DamageInflicted then
    if player.shield>0 and data.damage>1 then
      data.damage = data.damage - 1

    else 
      room:setPlayerMark(player,self.name,1)

    end
  elseif event==fk.Damaged then
      if player:getMark(self.name)>0 then
        room:setPlayerMark(player,self.name,0)
      room:changeShield(player,data.damage)
      end
  elseif event==fk.DamageCaused then
    if player.shield<data.to.shield then
      room:changeShield(player,data.to.shield)
    else
      room:loseHp(data.to, data.damage, self.name)
    end

  else
    data.n = data.n + player.shield

  end
    
  end,


}

--魂佑

local hunyou = fk.CreateTriggerSkill{
  name = "jbskl__hunyou",
  anim_type = "defensive",
  frequency = Skill.Compulsory,
  events = {fk.EventPhaseStart, fk.DamageInflicted},
  can_trigger = function(self, event, target, player, data)
    if event == fk.EventPhaseStart then
      return target == player and player:hasSkill(self.name) and player.phase == Player.Finish 
    else
      return target == player and player:hasSkill(self.name) and player:usedSkillTimes(self.name, Player.HistoryTurn) ==0
    end
  end,

  on_use = function(self, event, target, player, data)
    local room=player.room
    if event == fk.EventPhaseStart then
      room:changeShield(player,1)
    else
      return true
    end
  end,


}




--折射
local zheshe = fk.CreateTriggerSkill{
  name = "jbskl__zheshe",
  anim_type = "masochism",
  frequency = Skill.Compulsory,
  events = {fk.Damaged},
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self.name) and data.from and player:getMark("zheshe-turn")==0
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local from = data.from
    if from and not from.dead then room:doIndicate(player.id, {from.id}) end
    local judge = {
      who = player,
      reason = self.name,
      pattern = ".|.|^heart",
    }
    room:judge(judge)
    if judge.card.color ~=Card.Black and from and not from.dead then
        room:damage{
          from = player,
          to = from,
          damageType = fk.FireDamage,
          damage = 1,
          skillName = self.name,
        }
    else
        if not from:isKongcheng() then
          from:throwAllCards("h")
          room:setPlayerMark(player,"zheshe-turn",1)
        end
    end
  end,
}

--天罚

local tianfa= fk.CreateTriggerSkill{
  name = "jbskl__tianfa",
  anim_type = "support",
  events = {fk.RoundStart,fk.EventPhaseStart},
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    if event==fk.RoundStart then
      return player:hasSkill(self.name) and player.room:getTag("RoundCount")%2==0

    else
      return target == player and player.phase == Player.Start and player:hasSkill(self.name)
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event==fk.RoundStart then
      room:changeShield(player,3)
    else
    
        room:addPlayerMark(player,"@jbskl_wushiti",1)
    
    
    end
    
  end,
}

--觉醒

local juexing = fk.CreateTriggerSkill{
  name = "jbskl__juexing",
  anim_type = "defensive",
  frequency = Skill.Compulsory,
  events = {fk.AskForPeaches},
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self.name) and player.dying and player:usedSkillTimes(self.name, Player.HistoryGame) ==0
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    player:throwAllCards("hej")
    if player.dead then return end
    if not player.faceup then
      player:turnOver()
    end
    if player.chained then
      player:setChainState(false)
    end
    player:drawCards(player.maxHp, self.name)
    if player.dead or not player:isWounded() then return end
    room:recover({
      who = player,
      num = player.maxHp- player.hp,
      recoverBy = player,
      skillName = self.name,
    })
      room:setPlayerMark(player, "@jbskl_wushiti", 1)
      room:addPlayerMark(player, "@jbskl_attackbuff", 1)
      
  end,
}

--神佑

local shenyou= fk.CreateTriggerSkill{
  name = "jbskl__shenyou",
  anim_type = "defensive",
  frequency = Skill.Compulsory,
  events = {fk.DamageInflicted},
  can_trigger = function(self, event, target, player, data)
    
      return target == player and player:hasSkill(self.name) 
    
  end,

  on_use = function(self, event, target, player, data)
    local room=player.room
  
    data.damage=math.max(data.damage-player:getMark("@jbskl_shenyou-turn"),0)

    room:addPlayerMark(player,"@jbskl_shenyou-turn",1)
    
  end,


}


--反应

local fanying=fk.CreateTriggerSkill{
  name = "jbskl__fanying",
 
  frequency = Skill.Compulsory,
  events = {fk.CardUsing, fk.CardResponding},
  can_trigger = function(self, event, target, player, data)
    return target ~= player and player:hasSkill(self.name) and data.card and player:getMark("@jbskl_fanying-turn")==0
  end,
  on_use = function(self, event, target, player, data)
    local room=player.room
    local reflects=math.random(1,6)
    if reflects==1 then
      room:damage{
        from=player,
        to = target,
        damageType = fk.FireDamage,
        damage = 1,
        skillName = self.name,
      }
     

    elseif reflects==2 then  
      target:turnOver()
    
    elseif reflects==3 then  
      room:damage{
        from=player,
        to = target,
        damageType = fk.ThunderDamage,
        damage = 1,
        skillName = self.name,
      }
     

    elseif reflects==4 then  
   
      room:setPlayerMark(player, "@jbskl_fanying-turn", 1)
      

    elseif reflects==5 then  
      room:setPlayerMark(target, "@@jbs_kl__dongjie-turn", 1)
    


    elseif reflects==6 then  
      local skills = {}
      local pskills = {}
      --[[
            for _, skill in ipairs(target.player_skills)  do
              if not string.find(skill.name, "#") then
                table.insert(pskills, skill.name)
              end
            end
            if #pskills>0 then
              local choice = table.random(pskills,1)[1]
             room:handleAddLoseSkills(target, "-"..choice, nil, true, false)
  
             --]]
              for _, general in ipairs(Fk:getAllGenerals()) do
              for _, skill in ipairs(general.skills) do
                if not player:hasSkill(skill) then
                  table.insertIfNeed(skills, skill.name)
                end
              end
              end
              
              if #skills > 0 then
                local skill = table.random(skills,1)[1]
                room:handleAddLoseSkills(player, skill, nil, true, false)
              end

           -- end
          
            
    end
  end,
}


--冻结


local jbskl_card__prohibit = fk.CreateProhibitSkill{
  name = "#jbskl__prohibit",
  prohibit_use = function(self, player, card)
    return player:getMark("@@jbs_kl__dongjie-turn") > 0
  end,
  prohibit_response = function(self, player, card)
    return player:getMark("@@jbs_kl__dongjie-turn") > 0
  end,
}

fanying:addRelatedSkill(jbskl_card__prohibit)



--怒啸

local nuxiao= fk.CreateTriggerSkill{
  name = "jbs_kl_nuxiao",
  frequency = Skill.Compulsory,
  anim_type = "offensive",
  events = {fk.EventPhaseStart},
  can_trigger = function(self, _, target, player, data)
    return target:hasSkill(self.name) and player:getMark("@jbs_nuxiao-tur")>0 and target.phase == Player.Start
  end,
  on_use = function(self, _, target, player, data)
    local room = target.room
    local x=player:getMark("@jbs_nuxiao-tur")
    room:setPlayerMark(player, "@jbs_nuxiao-tur", 0)
    room:loseHp(player, x, self.name)

  end,

  refresh_events = {fk.AfterSkillEffect},
  can_refresh = function(self, _, target, player, data)
    return player:hasSkill(self.name) and
      target and target ~= player and
      target:hasSkill(data) and data.visible
  end,
  on_refresh = function(self, event, target, player, data)
    local room = player.room
   
    local n = 1
    for _, p in ipairs(room:getOtherPlayers(target)) do
          if p:getMark("@jbs_nuxiao-tur")> 0 then
            
            n =n+ p:getMark("@jbs_nuxiao-tur")
            room:setPlayerMark(p, "@jbs_nuxiao-tur", 0)


          end
    end
  room:addPlayerMark(target, "@jbs_nuxiao-tur", n)
  
  end,
}

--雄豪

local xionghao = fk.CreateFilterSkill{
  name = "jbskl__xionghao",
  anim_type = "offensive",
  card_filter = function(self, to_select, player)
    return player:hasSkill(self.name) and to_select.type == Card.TypeTrick
  end,
  view_as = function(self, to_select)
    return Fk:cloneCard("duel", to_select.suit, to_select.number)
  end,
}

--天灾

local tianzai = fk.CreateTriggerSkill{
  name = "jbskl__tianzai",
  frequency = Skill.Compulsory,
  mute=true,
  events = {fk.RoundStart,fk.CardUsing, fk.CardResponding,fk.EnterDying},
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self.name) then
      if event == fk.RoundStart or event==fk.EnterDying then
        return true
      else
        return target==player and data.card
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local to = room:printCard("jbs_kl_yibing_card", Card.Spade,13)
    if event == fk.RoundStart or event==fk.EnterDying then
     
      for i = 1, 3 do
      
        
        table.insert(room.draw_pile, math.random(1, #room.draw_pile),to.id )
        room:setCardArea(to.id, Card.DrawPile, nil)
      end
      room:notifySkillInvoked(player, "jbskl__tianzai", "special")
      room:doBroadcastNotify("UpdateDrawPile", tostring(#room.draw_pile))


    else
      table.insert(room.draw_pile, math.random(1, #room.draw_pile),to.id )
      room:setCardArea(to.id, Card.DrawPile, nil)
      room:notifySkillInvoked(player, "jbskl__tianzai", "special")
      room:doBroadcastNotify("UpdateDrawPile", tostring(#room.draw_pile))


    end
  end,
}


--圣物

local shengwu = fk.CreateTriggerSkill{
  name = "jbskl__shengwu",
  anim_type = "control",
  frequency = Skill.Compulsory,
  events = {fk.Death},
  can_trigger = function(self, event, target, player, data)
    
      return target == player and player:hasSkill(self.name, false, true) and data.damage and data.damage.from and not data.damage.from.dead
    
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    
    local to = data.damage.from
   
    local choice = math.random(1,3)
    if choice == 1 then
      room:setPlayerMark(to,"@@jbs_kl_ciyuanshengwu",1)
      room:addPlayerMark(to,"jbs_kl_shengwu",1)

      room:handleAddLoseSkills(to, "#jbskl__shengwu_ciyuan", nil, true, false)
           
    elseif choice ==2 then
      
      room:setPlayerMark(to,"@@jbs_kl_miejueshengwu",1)
      room:addPlayerMark(to,"jbs_kl_shengwu",1)
      room:handleAddLoseSkills(to, "#jbskl__shengwu_miejue", nil, true, false)

    elseif choice == 3 then
      room:setPlayerMark(to,"@@jbs_kl_huanmieshengwu",1)
      room:addPlayerMark(to,"jbs_kl_shengwu",1)
      room:handleAddLoseSkills(to, "#jbskl__shengwu_huanmie", nil, true, false)
           

    end

    


  end,
}

local shengwu_ciyuan= fk.CreateTriggerSkill{
  name = "#jbskl__shengwu_ciyuan",
  mute = true,
  frequency = Skill.Compulsory,
  events = {fk.AfterCardsMove},
  can_trigger = function(self, event, target, player, data)
      if player:hasSkill(self.name) and player:getMark("jbs_kl_shengwu")>0 then
        for _, move in ipairs(data) do
          return move.to == player.id and move.toArea == Player.Hand and move.skillName ~= self.name and  move.skillName ~= "zishu" and
          move.skillName ~= "zhanji"
        end
      end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local n=player:getMark("jbs_kl_shengwu")
    room:notifySkillInvoked(player, self.name, "drawcard")
    player:drawCards(n,self.name)
  end,
}

local shengwu_miejue = fk.CreateTriggerSkill{
  name = "#jbskl__shengwu_miejue",
  frequency = Skill.Compulsory,
  events = {fk.CardUsing, fk.CardResponding},
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self.name) and player:getMark("jbs_kl_shengwu")>0 then
        return target==player and data.card
    end

  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if player.role~="lord" then
      for _, p in ipairs(room:getAllPlayers()) do
        if p.role=="lord" then
          local cards = table.filter(p.player_cards[Player.Hand], function (id)
            return not p:prohibitDiscard(Fk:getCardById(id))
          end)
          if #cards > 0 then
            local id = table.random(cards,math.min(#cards,player:getMark("jbs_kl_shengwu")))
            room:throwCard(id, self.name, p)
          end
        end
      end
   
    else
      local targets = table.map(room:getOtherPlayers(player), function(p) return p.id end)
      local to
      if #targets > 0 then
        to = room:getPlayerById(table.random(targets))
       
      end
      local cards = table.filter(to.player_cards[Player.Hand], function (id)
        return not to:prohibitDiscard(Fk:getCardById(id))
      end)
      if #cards > 0 then
        local id = table.random(cards,math.min(#cards,player:getMark("jbs_kl_shengwu")))
        room:throwCard(id, self.name, to)
      end


    end

  end,
}

local shengwu_huanmie = fk.CreateTriggerSkill{
  name = "#jbskl__shengwu_huanmie",
  frequency = Skill.Compulsory,
  events = {fk.Damaged},
  can_trigger = function(self, event, target, player, data)
    
      return player:hasSkill(self.name) and not player.dead and player:getMark("jbs_kl_shengwu")>0 and data.from and
      data.from==player and not data.from.dead and not data.to.dead and data.damage and data.skillName ~= "#jbskl__shengwu_huanmie" 
  end,
  on_use = function(self, event, target, player, data)
      player.room:damage{
        from = player,
        to = target,
        damage =player:getMark("jbs_kl_shengwu"),
        skillName = self.name,
      }
     
  
  end,
}




--圣物more

local shengwumore = fk.CreateTriggerSkill{
  name = "jbskl__shengwumore",
  anim_type = "special",
  frequency = Skill.Compulsory,
  events = {fk.EventPhaseStart},
  can_trigger = function(self, event, target, player, data)
    
      return target == player and player:hasSkill(self.name) and player.phase == Player.Start 
    
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room

    room:addPlayerMark(player,"jbs_kl_shengwu",1)
   
  

    


  end,
}

shengwumore:addRelatedSkill(shengwu_ciyuan)
shengwumore:addRelatedSkill(shengwu_miejue)
shengwumore:addRelatedSkill(shengwu_huanmie)


--极限

local jixian = fk.CreateTriggerSkill{
  name = "jbskl__jixian",
  anim_type = "support",
  frequency = Skill.Compulsory,
  events = {fk.Damage},
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self.name) and target == player
  end,

  on_use = function(self, event, target, player, data)
    player:drawCards(1)
  end,

}

--雪崩

local xuebeng = fk.CreateTriggerSkill{
  name = "jbskl__xuebeng",
  anim_type = "defensive",
  mute=true,
  frequency = Skill.Compulsory,
  events = {fk.EventPhaseStart},
  can_trigger = function(self, event, target, player, data)
    if not player:hasSkill(self.name) then return false end
  return  target.phase == Player.Start
  end,

  on_use = function(self, event, target, player, data)
      local room=player.room
      local targets = table.map(room:getOtherPlayers(player), function(p) return p.id end)
      if #targets>0 then
        if target==player  then
          for _, to in ipairs(targets) do
            room:setPlayerMark(room:getPlayerById(to), "@@jbs_kl__dongjie-turn", 1)
          end
        else
          if #room.alive_players>2 then
            local tar=table.random(targets,#room.alive_players-2)
            for _, to in ipairs(tar) do
              room:setPlayerMark(room:getPlayerById(to), "@@jbs_kl__dongjie-turn", 1)
            end
          end

        end
      end
  end,


}

local jbskl_card__prohibit_sec = fk.CreateProhibitSkill{
  name = "#jbskl__prohibit_sec",
  prohibit_use = function(self, player, card)
    return player:getMark("@@jbs_kl__dongjie-turn") > 0
  end,
  prohibit_response = function(self, player, card)
    return player:getMark("@@jbs_kl__dongjie-turn") > 0
  end,
}

local xuebeng_attack = fk.CreateTriggerSkill{
  name = "#jbskl__xuebeng_attack",
  frequency = Skill.Compulsory,
  events = {fk.TargetSpecified},
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self.name) and data.card and data.card.is_damage_card and player.room:getPlayerById(data.to):getMark("@@jbs_kl__dongjie-turn")>0
  end,
  on_use = function(self, event, target, player, data)
    player.room:loseHp(player.room:getPlayerById(data.to), 1, self.name)
  end,
}

xuebeng:addRelatedSkill(xuebeng_attack)
xuebeng:addRelatedSkill(jbskl_card__prohibit_sec)

--奸雄

local jianxiong = fk.CreateTriggerSkill{
  name = "jbskl__jianxiong",
  frequency = Skill.Compulsory,
  anim_type = "masochism",
  events = {fk.Damaged},
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self.name) and data.from
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local n =math.min(player:usedSkillTimes(self.name, Player.HistoryGame), 5)
    player:drawCards(n, self.name)
    if not player.dead and data.card and table.every(data.card and data.card:isVirtual() and data.card.subcards or {data.card.id}, function(id)
      return room:getCardArea(id) == Card.Processing end) then
      local from = data.from
      room:obtainCard(player.id, data.card, true, fk.ReasonJustMove)
      local pskills = {}
      for _, skill in ipairs(from.player_skills)  do
        if not string.find(skill.name, "#") then
          table.insert(pskills, skill.name)
        end
      end
      if #pskills>0 then
        local choice = table.random(pskills,1)[1]
     
        room:handleAddLoseSkills(from, "-"..choice, nil, true, false)
        room:handleAddLoseSkills(player, choice, nil, true, false)
        
        
      end

    end
  end,
}

--导演
local daoyan = fk.CreateTriggerSkill{
  name = "jbskl__daoyan",
  frequency = Skill.Compulsory,
  anim_type = "support",
  mute = true,
  events = {fk.EventPhaseStart},
  can_trigger = function(self, event, target, player, data)
    if not player:hasSkill(self.name) then return false end
    return  target.phase == Player.Start
  end,
 
  on_use = function(self, event, target, player, data)
    local room = player.room
    for i=1 ,math.min(5,player:usedSkillTimes(self.name, Player.HistoryGame)) do
      local cards = player.room:getCardsFromPileByRule(".|.|.|.|.|trick")
      if #cards > 0 then
          room:obtainCard(player, cards[1], true, fk.ReasonJustMove)
      end
    end
    
  end,
}

local daoyan_buff = fk.CreateTriggerSkill{
  name = "#jbs__daoyan_buff",
  anim_type = "offensive",
  events = {fk.CardUsing},
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self.name) and data.card.is_damage_card and data.card.type==Card.TypeTrick
  end,
  on_use = function(self, event, target, player, data)
    data.extra_data = data.extra_data or {}
    data.extra_data.daoyan = data.extra_data.daoyano or true
  end,

  refresh_events = {fk.CardUseFinished},
  can_refresh = function(self, event, target, player, data)
    return data.extra_data and data.extra_data.daoyan
  end,
  on_refresh = function(self, event, target, player, data)
    data.extra_data.daoyan = false
    player.room:doCardUseEffect(data)
  end,
}

daoyan:addRelatedSkill(daoyan_buff)

--天佑

local tianyou = fk.CreateTriggerSkill{
  name = "jbskl__tianyou",
  events = {fk.HpChanged},
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    return target==player and player:hasSkill(self.name) and not player.dead  and player:usedSkillTimes(self.name, Player.HistoryGame)<1 and 
    player.hp<=player.maxHp//2 and player.hp>0
  end,

  on_use = function(self, event, target, player, data)
    local room = player.room
    local n=player.maxHp- player.hp
    room:recover({
      who = player,
      num = n,
      recoverBy = player,
      skillName = self.name,
    })
    for i=1 ,math.max(n//2,1) do
      local targets = table.map(room:getOtherPlayers(player), function(p) return p.id end)
      if #targets>0 then
          local to = room:getPlayerById(table.random(targets))
          room:loseHp(to, 1, self.name)
      end
    end

  


    

  end,
}

--炸弹

local zhadan = fk.CreateTriggerSkill{
  name = "jbskl__zhadan",
  anim_type = "offensive",
  frequency = Skill.Compulsory,
  events = {fk.EventPhaseStart},
  can_trigger = function(self, event, target, player, data)
    if event==fk.EventPhaseStart then
      return target.phase == Player.Start and player:hasSkill(self.name)

    end
  end,

  on_use = function(self, event, target, player, data)
    local room=player.room
    local n=player.maxHp
    for i=1 ,math.max(n//10,1) do
      local targets = table.map(room:getOtherPlayers(player), function(p) return p.id end)
      if #targets>0 then
          local to = room:getPlayerById(table.random(targets))
          room:damage{
            from=player,
            to = to,
            damageType = fk.FireDamage,
            damage = 1,
            skillName = self.name,
          }
          if to.dead then return true end
          local reflects=math.random(1,3)
          if reflects==1 then
            --[[
            local skills = {}
            local pskills = {}
                  for _, skill in ipairs(to.player_skills)  do
                    if not string.find(skill.name, "#") then
                      table.insert(pskills, skill.name)
                    end
                  end
                  if #pskills>0 then
                    local choice = table.random(pskills,1)[1]
                   room:handleAddLoseSkills(to, "-"..choice, nil, true, false)
        
                    for _, general in ipairs(Fk:getAllGenerals()) do
                    for _, skill in ipairs(general.skills) do
                      if not player:hasSkill(skill) then
                        table.insertIfNeed(skills, skill.name)
                      end
                    end
                    end
                    if #skills > 0 then
                      local skill = table.random(skills,1)[1]
                      room:handleAddLoseSkills(to, skill, nil, true, false)
                    end
      
                  end
--]]
              room:loseHp(to,1,self.name)
          elseif reflects==2 then
            room:changeMaxHp(player, 3)
            room:recover{
              who = player,
              num = 3,
              recoverBy = player,
              skillName = self.name,
            }
          else
            room:changeMaxHp(to, -1)
          end
      end
    end
  end,


}

--灵佑

local lingyou = fk.CreateTriggerSkill{
  name = "jbskl__lingyou",
  anim_type = "offensive",
  frequency = Skill.Compulsory,
  events = {fk.RoundStart},
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self.name)
  end,

  on_use = function(self, event, target, player, data)
    local room=player.room
    local n=0
    for i, m in pairs(player.mark) do
      if string.find(i, "@") and i~="@jbskl_attackbuff"  and i~="@jbskl_boci" and i~="@jbskl_wushiti" and i~="@jbskl__buxiu" and type(m) == "number" then
        n=n+(m or 0 )
        room:setPlayerMark(player, i, 0)
      end
  
    end

    for i=1 ,n do
      
      local targets = table.map(room:getOtherPlayers(player), function(p) return p.id end)
      if #targets>0 then
          local to = room:getPlayerById(table.random(targets))
          --吸取体力
            room:loseHp(to, 1, self.name)
            room:recover({
              who = player,
              num = 1,
              recoverBy = player,
              skillName = self.name,
            })
            if to.dead then return true end

            room:changeMaxHp(to, -1)
            room:changeMaxHp(player, 1)
            if to.dead then return true end
            

      end
      --]]
      
      room:addPlayerMark(player,"@jbskl_attackbuff",1)

    

     

    end
  end,


}


--地佑

local diyou = fk.CreateTriggerSkill{
  name = "jbskl__diyou",
  frequency = Skill.Compulsory,
  events = {fk.HpChanged},
  can_trigger = function(self, event, target, player, data)
    return target:hasSkill(self.name)  and  target.maxHp -player.maxHp <0
        
  end,
  on_use = function(self, event, target, player, data)
    local n=player.maxHp-target.maxHp
    target.room:changeMaxHp(target,n)
    target.room:recover({
      who = target,
      num =n,
      recoverBy = target,
      skillName = self.name,
    })
  end,
}


--龙息

local longxi= fk.CreateTriggerSkill{
  name = "jbskl__longxi",
  frequency = Skill.Compulsory,
  anim_type = "offensive",
  events = {fk.AfterSkillEffect},
  can_trigger = function(self, _, target, player, data)
    return player:hasSkill(self.name) and
      target and target ~= player and
      target:hasSkill(data) and data.visible
  end,
  on_use = function(self, _, target, player, data)
    player.room:addPlayerMark(player, "@jbs_long",1)
    player:drawCards(2, self.name)
  end,

 
}

--虚空
local xukong = fk.CreateTriggerSkill{
  name = "jbskl__xukong",
  anim_type = "defensive",
  frequency = Skill.Compulsory,
  events = {fk.EventPhaseStart,fk.GameStart,fk.EventAcquireSkill},
  can_trigger = function(self, event, target, player, data)
    if event==fk.EventPhaseStart then
      return target.phase == Player.Finish and  player:hasSkill(self.name)
    elseif event == fk.EventAcquireSkill then
      return target==player and data == self 
    else 
      return player:hasSkill(self.name)
    end
  end,

  on_use = function(self, event, target, player, data)
    local room=player.room
    if event == fk.GameStart or event == fk.EventAcquireSkill then
      
        for _, p in ipairs(room:getOtherPlayers(player)) do
          room:handleAddLoseSkills(p, "jbskl__xukong&", nil, false, true)
        end
      
    else
      room:addPlayerMark(player, "@jbskl_xukong",2)
      room:changeMaxHp(player, -2)
    end
  end,


}

local xukong_active = fk.CreateActiveSkill{
  name = "jbskl__xukong&",
  anim_type = "support",
  prompt="#jbskl_xukongac",
  target_num = 1,
  can_use = function(self, player)
    return true
  end,
  target_filter = function(self, to_select, selected)
    return #selected == 0 and to_select ~= Self.id and Fk:currentRoom():getPlayerById(to_select):hasSkill("jbskl__xukong")
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local target = room:getPlayerById(effect.tos[1])
    room:loseHp(player, 1, self.name)
    room:removePlayerMark(target, "@jbskl_xukong", 1)

  end,
}

Fk:addSkill(xukong_active)

--不朽
local buxiu = fk.CreateTriggerSkill{
  name = "jbskl__buxiu",
  anim_type = "defensive",
  frequency = Skill.Compulsory,
  events = {fk.DamageInflicted, fk.EventPhaseStart},
  can_trigger = function(self, event, target, player, data)
    if target == player and player:hasSkill(self.name) then
      if event == fk.DamageInflicted then
        return true
      else
        return player.phase == Player.Finish and player:getMark("@jbskl__buxiu") > 0
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.DamageInflicted then
      room:addPlayerMark(player, "@jbskl__buxiu", data.damage)
      return true
    else
      local n = player:getMark("@jbskl__buxiu")
      room:setPlayerMark(player, "@jbskl__buxiu", 0)
      room:loseHp(player, n//2, self.name)
    end
  end,
}


--护甲

local shanghai  = fk.CreateTriggerSkill{
  name = "jbskl__shanghai",
  anim_type = "defensive",
  frequency = Skill.Compulsory,
  events = {"fk.shieldchanged"},
  can_trigger = function(self, event, target, player, data)

      return target == player and player:hasSkill(self.name) 
  end,
  on_use = function(self, event, target, player, data)
    local room=player.room
    --data.num=data.num+1
    local targets=pvetool:getenemy(room)
    for _, p in ipairs(targets) do
      local to = room:getPlayerById(p)
      room:damage{
        from = player,
        to = to,
        damage = data.num,
        skillName = self.name,
      
      }

    
    end
   
   
    
       
  end,


}

--湮灭

local yanmie = fk.CreateTriggerSkill{
  name = "jbskl__yanmie",
  frequency = Skill.Compulsory,
  events = {fk.DamageFinished},
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self.name) then
      if data.extra_data and data.extra_data.klyanmie_invoke then
        return true
      end
      if data.to:getMark("yanmie-phase") > 0 and data.from==player then
        player.room:setPlayerMark(data.to, "yanmie-phase", 0)--FIXME: 伪实现！！！
        return true
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    player.room:loseHp(target, 1, self.name)

  end,

  refresh_events = {fk.PreDamage, fk.AfterSkillEffect, fk.Damaged},
  can_refresh = function(self, event, target, player, data)
    return true
  end,
  on_refresh = function(self, event, target, player, data)
    if event == fk.PreDamage then
      data.extra_data = data.extra_data or {}
      data.extra_data.klyanmie = data.damage
      player.room:setPlayerMark(data.to, "yanmie-phase", 1)--FIXME
    elseif event == fk.AfterSkillEffect then
      local e = player.room.logic:getCurrentEvent():findParent(GameEvent.Damage)
      if e then
        local dat = e.data[1]
        if dat.extra_data and dat.extra_data.klyanmie and dat.damage < dat.extra_data.klyanmie then
          dat.extra_data.klyanmie_invoke = true
        end
      end
    elseif event == fk.Damaged then
      player.room:setPlayerMark(data.to, "wuji-phase", 0)--FIXME
    end
  end,
}


--技能添加=

jbs_kl_menghuo:addSkill("huoshou")
jbs_kl_menghuo:addSkill(manwang)

jbs_kl_yuanshao:addSkill(mingmen)

jbs_kl_machao:addSkill("ex__tieji")

jbs_kl_lvbu:addSkill("wushuang")




jbs_kl_baluoka:addSkill(zhenhun)
jbs_kl_baluoka:addSkill(hunyou)


jbs_kl_sjtunshizhe:addSkill(jishi)

jbs_kl_lvmeng:addSkill("jbs__diandeng")
jbs_kl_lvmeng:addSkill("jbskl__mingyun")
jbs_kl_lvbu:addSkill("jbs__jianhao")
jbs_kl_machao:addSkill("jbs__shenjun")


jbs_kl_daqiao:addSkill("guose")
jbs_kl_daqiao:addSkill(juese)
jbs_kl_daqiao:addSkill(mingyun)

jbs_kl_peitefede:addSkill(duohun)
jbs_kl_peitefede:addSkill("jbskl__shenpan")


jbs_kl_sjtunshizhe:addSkill(shenpan)

jbs_kl_gufu:addSkill(chengzhang)
jbs_kl_gufu:addSkill(zheshe)
jbs_kl_gufu:addRelatedSkill("jbskl__shenpan")
jbs_kl_gufu:addRelatedSkill("jbskl__mingyun")
jbs_kl_gufu:addRelatedSkill("jbs__diandeng")
jbs_kl_gufu:addRelatedSkill("jbskl__jishi")





jbs_kl_tianfa:addSkill(tianfa)
jbs_kl_tianfa:addSkill(shenyou)


jbs_kl_gulong:addSkill("jbs__longwei")
jbs_kl_gulong:addSkill("jbs__longhun")



jbs_kl_juexingzhe:addSkill(juexing)


jbs_kl_yuanshen:addSkill(fanying)
jbs_kl_yuanshen1:addSkill("jbskl__fanying")
jbs_kl_yuanshen1:addSkill("jbskl__zheshe")

jbs_kl_yuanshen:addSkill("jbskl__mingyun")

jbs_kl_changyou:addSkill(nuxiao)
jbs_kl_changyou:addSkill(jixian)




jbs_kl_yanliangwenchou:addSkill(xionghao)
jbs_kl_yanliangwenchou:addSkill("jbs__jianhao")

jbs_kl_haila:addSkill(tianzai)



jbs_kl_shengwujiang:addSkill(shengwu)


jbs_kl_shengwujiangl:addSkill("jbskl__shengwu")
jbs_kl_shengwujiangl:addSkill(shengwumore)

jbs_kl_xuebeng:addSkill(xuebeng)
jbs_kl_caocao:addSkill(jianxiong)
jbs_kl_caocao:addSkill(diyou)

--jbs_kl_ygsl:addSkill(daoyan)
jbs_kl_ygsl:addSkill(tianyou)
jbs_kl_ygsl:addSkill("jbszf_daoyan")




jbs_kl_kazhakusi:addSkill(longxi)
jbs_kl_kazhakusi:addSkill("jbskl__lingyou")


jbs_kl_keli:addSkill(zhadan)
--jbs_kl_peitefede:addSkill(lingyou)
jbs_kl_sagelasi:addSkill(xukong)
jbs_kl_sagelasi:addSkill(buxiu)
jbs_kl_sagelasi:addSkill(lingyou)


jbs_kl_aoding:addSkill("jbskl__hunyou")
jbs_kl_aoding:addSkill(shanghai)

--jbs_kl_peitefede:addSkill(yanmie )


--jbs_kl_peitefede:addSkill(test)




Fk:loadTranslationTable{
    ["jbs_kl_menghuo"]="孟获",
    ["jbs_kl_machao"]="马超",
    ["jbs_kl_lvbu"]="吕布",
    ["jbs_kl_yuanshao"]="袁绍",
    ["jbs_kl_lvmeng"]="吕蒙",
    ["jbs_kl_baluoka"]="巴弗洛",
    ["jbs_kl_sjtunshizhe"]="时间吞噬者",
    ["jbs_kl_daqiao"]="大乔",
    ["jbs_kl_gufu"]="古夫",
    ["jbs_kl_peitefeide"]="佩特菲德",
    ["jbs_kl_tianfa"]="天罚",
    ["jbs_kl_gulong"]="顾龙",
    ["jbs_kl_juexingzhe"]="觉醒者",
    ["jbs_kl_changyou"]="长右",
    ["jbs_kl_yuanshen"]="原神",
    ["jbs_kl_yuanshen1"]="原神",
    ["jbs_kl_yanliangwenchou"]="颜良文丑",
    ["jbs_kl_haila"]="海拉",
    ["jbs_kl_shengwujiang"]="圣物酱",
    ["jbs_kl_shengwujianglast"]="赛·墨克斯",
    ["jbs_kl_caocao"]="曹操",
    ["jbs_kl_xuebeng"]="雪崩",
    ["jbs_kl_ygsl"]="尤格萨隆",
    ["jbs_kl_keli"]="可莉",
    ["jbs_kl_kazhakusi"]="卡扎库斯",
    ["jbs_kl_sagelasi"]="萨格拉斯",
    ["jbs_kl_aoding"]="奥丁",
    ["jbs_kl_liutang"]="刘唐",



    ["jbskl__manwang"]="蛮王",
    ["jbskl__mingmen"]="名门",
    [":jbskl__mingmen"]="锁定技，出牌阶段开始时，你视为使用x张[万箭齐发]（x=你已损失体力值+1）",
    ["jbskl__zhenhun"]="镇魂",
    [":jbskl__zhenhun"]="锁定技，你第5个回合结束时，杀死所有其他玩家。",

    ["jbskl__juese"]="绝色",
    [":jbskl__juese"]="锁定技，你回合结束时，对一名其他角色造成1点火焰伤害。",

    ["jbskl__jishi"]="计时",
    ["@jbskl__jishi"]="计时",
    [":jbskl__jishi"]="锁定技，当其他角色累计使用/打出8张牌时，对当前回合角色造成2点雷电伤害，若此时不是你的回合，立即结束当前回合。",

    ["jbskl__yanmie"]="湮灭",
    [":jbskl__yanmie"]="锁定技，你的伤害被防止时，使目标失去1点体力",

    ["jbskl__mingyun"]="命运",
    [":jbskl__mingyun"]="锁定技，你每轮行动两个回合",

    ["jbskl__tianfa"]="天罚",
    [":jbskl__tianfa"]="锁定技，偶数轮开始时，获得一层增伤，一层无实体和3点护甲；你的回合开始时，获得一层无实体。",


    ["jbskl__hunyou"]="魂佑",
    [":jbskl__hunyou"]="锁定技，免疫每回合第一次伤害,每回合结束获得1点护甲",

    ["jbskl__duohun"]="堕魂",
    [":jbskl__duohun"]="锁定技,你造成伤害时，若护甲少于目标，则获得等同于目标的护甲，否则则令目标失去等额体力；你受到伤害时，若你有护甲，则使伤害-1，否则受到伤害后获得伤害值的护甲;你的摸牌阶段摸牌数+n（n为你护甲数）",

  
    ["jbskl__chengzhang"]="成长",
    ["$jbskl__chengzhang1"]="成长，生命，幸福，还有朋友。",
    [":jbskl__chengzhang"]="锁定技，每局游戏限2次，你处于濒死状态时，弃置所有牌，增加一定体力上限，回复所有体力并将手牌补至上限，立即结束当前回合。每次复活得到一定增益",
    

    ["jbskl__zheshe"]="折射",
    [":jbskl__zheshe"]="锁定技，你受到伤害时判定：若结果不为黑色，则对伤害来源造成1点火焰伤害，否则弃置其所有手牌且本回合此技能失效。",

    ["@jbskl_zhenhun"]="镇魂",
    ["@jbskl_fanying-turn"]="反应失效",
    ["jbskl__shenpan"]="审判",
    [":jbskl__shenpan"]="锁定技，回合开始时，审判一名角色：其进行一次判定，若结果为黑色，则对其造成1次1点伤害，否则重复该流程并令伤害次数+1.",
    [":jbskl__manwang"]="锁定技，出牌阶段开始时，你视为使用x张[南蛮入侵]（x=你已损失体力值）。",


    ["jbskl__juexing"]="觉醒",
    [":jbskl__juexing"]="锁定技，每局游戏限1次，你处于濒死状态时，弃置所有牌，回复所有体力并将手牌补至上限，获得1层无实体和1层增伤",
  
    ["jbskl__shenyou"]="神佑",
    [":jbskl__shenyou"]="锁定技，你受到的伤害-x（x为你本回合受伤次数）",

    ["jbskl__fanying"]="反应",
    [":jbskl__fanying"]="锁定技，当一名角色使用或打出使用一张牌后，随机令其进行1个元素反应：<br>"..
    "蒸发反应，对其造成1点火焰伤害<br>"..
    "冻结反应,本回合不能再使用/打出手牌<br>"..
    "感电反应，对其造成1点雷电伤害<br>"..
    "融化反应，本回合【反应】失效<br>"..
    "超载反应，令其翻面<br>"..
    "超导反应，随机获得1个技能",

    ["jbs_kl_nuxiao"]="怒啸",
    [":jbs_kl_nuxiao"]="锁定技，当一名角色发动技能时，其获得1点元气并将场上元气数转移给他；你的回合开始时，拥有元气的角色造成失去等同元气数的体力并清除其所有元气。",

    ["jbskl__xionghao"]="雄豪",
    [":jbskl__xionghao"]="锁定技，你的锦囊牌视为决斗。",

    ["jbskl__tianzai"]="天灾",
    [":jbskl__tianzai"]="锁定技，每轮开始时/你进入濒死状态时将3张【疫病】;你使用或打出1张牌时，将1张【疫病】洗入牌堆（抽到【疫病】时会失去1点体力）",


    ["jbskl__shengwu"]="圣物",
    [":jbskl__shengwu"]="锁定技，杀死你的角色随机获得一个圣物。<br>1.次元圣物，你因其他效果获得牌时，额外摸1张牌<br>"..
    "2.灭绝圣物，你使用或打出一张牌后，随机弃置敌人1张手牌<br>3.幻灭心能圣物，你因其他效果造成伤害后，额外再造成1点伤害",

    ["jbskl__shengwumore"]="圣物",
    [":jbskl__shengwumore"]="锁定技，你拥有全部圣物。你的回合开始时，你提升以后的圣物效果。",

    ["jbskl__jixian"]="极限",
    [":jbskl__jixian"]="锁定技，你造成伤害时，摸1张牌",

    ["jbskl__xuebeng"]="雪崩",
    [":jbskl__xuebeng"]="锁定技，你的回合开始时，冻结所有其他角色，其他角色回合开始时，随机冻结x个其他角色（x为其他角色数-1）。当你使用伤害牌指定被冻结的角色后，使其失去1点体力。",

    ["jbskl__jianxiong"]="奸雄",
    [":jbskl__jianxiong"]="锁定技，你受到伤害后，你可以摸一张牌，并获得伤害牌且偷取伤害来源1个技能。当你发动此技能后，摸牌数+1(至多为5)。",
  
    ["jbskl__daoyan"]="导演",
    [":jbskl__daoyan"]="锁定技，每回合开始时，随机获得1张锦囊牌。当你发动此技能后，获得数+1(至多为5)。你的伤害锦囊牌额外结算一次。",

    ["jbskl__tianyou"]="天佑",
    [":jbskl__tianyou"]="每局游戏限1次，当你的体力不高于体力上限的一半且未进入濒死状态时，回复所有体力，令其他角色随机失去总计等同于回复值/2的体力（至少为1）。",

    
    ["jbskl__zhadan"]="炸弹",
    [":jbskl__zhadan"]="锁定技，回合开始时，可莉向随机敌人引爆总计x枚炸弹，每枚炸弹会对目标造成1点火焰伤害并随机执行一个额外效果：<br>1目标失去1点体力"..
    "<br>2.可莉体力上限+3并恢复3点体力<br>3.减少目标1点体力上限。(x为可莉的体力上限/10，且至少为1)",

    
    ["jbskl__lingyou"]="灵佑",
    [":jbskl__lingyou"]="锁定技，每轮开始时，清除你的非【增伤】/非【无实体】标记，每清除一枚，随机获得1层增伤并随机吸取对手1点体力上限",

    ["jbskl__diyou"]="地佑",
    [":jbskl__diyou"]="锁定技，你体力变化后，若你的体力上限不为全场最高，则增加x点体力上限并回复等额体力。（x=全场体力上限最大值-你的体力上限）",
    
    
    ["jbskl__longxi"]="龙息",
    [":jbskl__longxi"]="锁定技，当其他角色发动技能时，你获得1枚龙标记并摸1张牌。",

    ["jbskl__xukong"]="虚空",
    [":jbskl__xukong"]="锁定技，每名玩家回合结束时，你获得2枚“虚空”标记并失去2点体力上限，其他角色出牌阶段可以失去1点体力令你弃置1枚“虚空”。",

    ["jbskl__buxiu"]="不朽",
    [":jbskl__buxiu"]="锁定技，当你受到伤害时，防止此伤害并获得等量的“不朽”标记；结束阶段，你弃置所有的“不朽”标记并失去标记数/2的体力。",
    ["#jbskl__daoyan_buff"]="导演",
    ["jbskl__shanghai"]="铸魂",
    [":jbskl__shanghai"]="锁定技，你获得护甲时,对所有玩家造成等同于护甲值的伤害。",

    ["@@jbs_kl__dongjie-turn"]="冻结",
    ["@jbskl_shenyou-turn"]="神佑",
    ["@jbs_nuxiao-tur"]="元气",
    ["@jbskl_xukong"]="虚空",
    ["@jbskl__buxiu"]="不朽",

    ["@@jbs_kl_ciyuanshengwu"]="次元圣物",
    ["@@jbs_kl_miejueshengwu"]="灭绝圣物",
    ["@@jbs_kl_huanmieshengwu"]="幻灭心能圣物",
    
    ["#jbskl__shengwu_ciyuan"]="次元圣物",
    ["#jbskl__shengwu_miejue"]="灭绝圣物",
    ["#jbskl__shengwu_huanmie"]="幻灭心能圣物",
    
    ["#jbskl__prohibit"]="冻结",
    ["#jbskl__prohibit_sec"]="冻结",

    ["#jbs__daoyan_buff"]="导演",
    ["#jbskl__xuebeng_attack"]="雪崩",


    ["jbskl__xukong&"]="虚空",
    [":jbskl__xukong&"]="出牌阶段，你可以失去1点体力，使萨格拉斯失去1层【虚空】",
    ["#jbskl_xukongac"]="你可以失去1点体力，使萨格拉斯失去1层【虚空】",
}

return extension