local extension = Package("langchao")
extension.extensionName = "water"

Fk:loadTranslationTable{
  ["langchao"] = "浪潮",
  
}

local U = require "packages/utility/utility"
local T = require "packages/jbs/record/Theorem"
local pvetool = require "packages/jbs/record/PVETool"


local kuafu = General(extension, "langchao__kuafu","god",16)
local aolajier= General(extension, "langchao__aolajier","god",8)
kuafu.hidden=true
aolajier.hidden=true
local zhuri = fk.CreateTriggerSkill{
  name = "water__zhuri",
  anim_type = "drawcard",
  frequency = Skill.Compulsory,
  events = {fk.EventPhaseStart},
  can_trigger = function(self, event, target, player, data)
    return target == player and player.phase == Player.Start and player:hasSkill(self) 
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local judge = {
      who = player,
      reason = self.name,
      pattern = ".|.|heart,diamond,spade,club",
    }
    room:judge(judge)
    if judge.card.color == Card.Red then
      local mark = U.getMark(player, "@water__zhuri-turn")
      table.insertIfNeed(mark, "red")
      room:setPlayerMark(player, "@water__zhuri-turn", mark)
    elseif judge.card.color == Card.Black then
      local mark = U.getMark(player, "@water__zhuri-turn")
      table.insertIfNeed(mark, "black")
      room:setPlayerMark(player, "@water__zhuri-turn", mark)
    end
    
  end,
  refresh_events = {fk.CardUsing,fk.CardUseFinished},
  can_refresh = function(self, event, target, player, data)
    return target == player and data.card and player:getMark("@water__zhuri-turn") and table.contains(U.getMark(player, "@water__zhuri-turn"), data.card:getColorString()) 
    and (event == fk.CardUsing and data.card.color == Card.Black or event == fk.CardUseFinished and data.card.color == Card.Red 
    and (player.room:getCardArea(data.card) == Card.Processing or player.room:getCardArea(data.card) == Card.PlayerEquip))
  end,
  on_refresh = function(self, event, target, player, data)
    local room = player.room
    if data.card.color == Card.Red then
      room:moveCards({
        ids = {data.card.id},
        from = player.id,
        toArea = Card.DrawPile,
        moveReason = fk.ReasonJustMove,
        skillName = self.name,
        drawPilePosition = -1,
      })
    elseif data.card.color == Card.Black then
      player:drawCards(1,self.name)
    end
  end
}
local yinjiang = fk.CreateTriggerSkill{
  name = "water__yinjiang",
  anim_type = "offensive",
  frequency = Skill.Compulsory,
  events = {fk.AfterCardsMove},
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self) then
        if player.phase ~= Player.NotActive and player.phase == Player.Play then
          for _, move in ipairs(data) do
            return move.to == player.id and move.toArea == Player.Hand and move.skillName ~= self.name and table.find(move.moveInfo, function (info)
              return info.fromArea == Card.DrawPile  end)
          end
        end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local card = player:drawCards(1,self.name,"bottom")
    card = Fk:getCardById(card[1])
    if card.color == Card.Red then
      local tar = {}
      for _, p in ipairs(room.alive_players) do
        if  (player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist")) then
          table.insert(tar,p)
        end
      end
      if #tar > 0 then
      room:damage({
        from = player,
        to = table.random(tar),
        damage = 1,
        damageType = fk.NormalDamage,
        skillName = self.name,
      })
      end
    end
  end,
}
local lieben = fk.CreateTriggerSkill{
  name = "water__lieben",
  anim_type = "offensive",
  frequency = Skill.Compulsory,
  events = {fk.CardUsing},
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and data.card.trueName == "slash" 
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local judge = {
      card = Fk:getCardById(room:getNCards(1,"bottom")[1]),
      who = player,
      reason = self.name,
      pattern = ".|.|heart,diamond",
    }
    room:judge(judge)
    if judge.card.color == Card.Red then
      if not data.extraUse then
        data.extraUse = true
        target:addCardUseHistory(data.card.trueName, -1)
      end
      data.additionalDamage = (data.additionalDamage or 0) + 1
    end
  end,
}
local shenqu = fk.CreateTriggerSkill{
  name = "water__shenqu",
  anim_type = "drawcard",
  frequency = Skill.Compulsory,
  events = {fk.Damaged},
  can_trigger = function(self, event, target, player, data)
    if target == player and player:hasSkill(self)  then
      self.cancel_cost = false
     for _ = 1, data.damage do
        if player.dead or self.cancel_cost then return end
        self:doCost(event, target, player, data)
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local judge = {
      card = Fk:getCardById(room:getNCards(1,"bottom")[1]),
      who = player,
      reason = self.name,
      pattern = ".|.|heart,diamond",
    }
    room:judge(judge)
    if judge.card.color == Card.Red then
      if not player.dead then
        player:drawCards(1,self.name)
      end
      if data.from and not data.from.dead and not data.from:isNude() then
        local cards = data.from:getCardIds("he")
        room:moveCardTo(table.random(cards),Card.DiscardPile,player,fk.ReasonDiscard)
      end
    end
  end,
}
kuafu:addSkill(zhuri)
kuafu:addSkill(yinjiang)
kuafu:addSkill(lieben)
kuafu:addSkill(shenqu)
Fk:loadTranslationTable{
  ["langchao__kuafu"] = "夸父",

  ["water__zhuri"] = "逐日",
  [":water__zhuri"] = "锁定技，准备阶段，你进行判定，若判定结果为:红色，本回合你使用红色牌结算完毕后，将该牌放置于牌堆底；黑色，本回合你使用黑色牌时，你摸一张牌。",
  ["water__yinjiang"] = "饮江",
  [":water__yinjiang"] = "锁定技，当你在出牌阶段摸牌后，额外从牌堆底获得一张牌，若该牌是红色，则随机对一名敌方角色造成1点伤害。",
  ["water__lieben"] = "烈奔",
  [":water__lieben"] = "锁定技，当你使用【杀】时，使用堆底的牌进行判定：若结果为红色，则此杀不计入出牌阶段使用次数且伤害+1。",
  ["water__shenqu"] = "神躯",
  [":water__shenqu"] = "锁定技，当你受到1点伤害后，使用牌堆底的牌进行判定：若结果为红色，你摸一张牌，伤害来源随机弃置一张牌。",
  ["#water__shenqu"] = "神躯：你需弃置一张牌。",
  ["@water__zhuri-turn"] = "逐日",

  ["$water__zhuri"] = "狂飙八万里，逐日九重天！",
  ["$water__yinjiang"] = "大江三千顷，豪饮一息间。",
  ["$water__lieben"] = "奔雷析紫电，池鱼断清风。",
  ["$water__shenqu"] = "神躯天成，伤之必逝。",
  ["~langchao__kuafu"] = "大泽江河..",
}


local xuannv = General(extension, "langchao__xuannv","god",16,16,General.Female)
xuannv.hidden=true
local dishi = fk.CreateTriggerSkill{
  name = "water__dishi",
  anim_type = "control",
  events = {fk.TargetConfirming},
  can_trigger = function(self, event, target, player, data)
    local room = player.room
    if player:hasSkill(self) and (data.card:isCommonTrick() or data.card.trueName == "slash") and data.firstTarget then
      if #AimGroup:getAllTargets(data.tos) == 1 then
        local targets = U.getUseExtraTargets(room, data, true, true)
        local origin_targets = U.getActualUseTargets(room, data, event)
        if #origin_targets > 1 then
            table.insertTable(targets, origin_targets)
        end
        if (data.card.trueName == "slash" or data.card.is_damage_card or data.card.name == "dismantlement" or data.card.name == "snatch" or data.card.name == "iron_chain") then
          for _, p in ipairs(room.alive_players) do
              if ((player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist")))  and table.contains(targets,p.id) then
                return true
              end
          end
        else
          for _, p in ipairs(room.alive_players) do
            if ((player.role == "rebel" and p.role == player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role == "lord" or p.role == "loyalist")))  and table.contains(targets,p.id) then
              return true
            end
        end
        end
      elseif #AimGroup:getAllTargets(data.tos) > 1 then
        local origin_targets = U.getActualUseTargets(room, data, event)
        if (data.card.trueName == "slash" or data.card.is_damage_card or data.card.name == "dismantlement" or data.card.name == "snatch" or data.card.name == "iron_chain") then
          for _, pid in ipairs(origin_targets) do
            local p = room:getPlayerById(pid)
              if (player.role == "rebel" and p.role == player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role == "lord" or p.role == "loyalist"))  then
                return true
              end
          end
        else
          for _, pid in ipairs(origin_targets) do
            local p = room:getPlayerById(pid)
              if (player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist"))  then
                return true
              end
          end
        end
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local over = false
    if #AimGroup:getAllTargets(data.tos) == 1 then
      local targets = U.getUseExtraTargets(room, data, true, true)
      local origin_targets = U.getActualUseTargets(room, data, event)
      if #origin_targets > 1 then
          table.insertTable(targets, origin_targets)
      end
      if (data.card.trueName == "slash" or data.card.is_damage_card or data.card.name == "dismantlement" or data.card.name == "snatch" or data.card.name == "iron_chain") then
        for _, p in ipairs(room.alive_players) do
          if over then break end
            if ((player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist")))  and table.contains(targets,p.id) then
              player.room:doIndicate(player.id, {p.id})
              AimGroup:addTargets(player.room, data,p.id)
              over = true
            end
        end
      else
        for _, p in ipairs(room.alive_players) do
          if over then break end
          if ((player.role == "rebel" and p.role == player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role == "lord" or p.role == "loyalist")))  and table.contains(targets,p.id) then
            player.room:doIndicate(player.id, {p.id})
            AimGroup:addTargets(player.room, data,p.id)
          end
      end
      end
    elseif #AimGroup:getAllTargets(data.tos) > 1 then
      local origin_targets = U.getActualUseTargets(room, data, event)
      if (data.card.trueName == "slash" or data.card.is_damage_card or data.card.name == "dismantlement" or data.card.name == "snatch" or data.card.name == "iron_chain") then
        for _, pid in ipairs(origin_targets) do
          if over then break end
          local p = room:getPlayerById(pid)
            if ((player.role == "rebel" and p.role == player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role == "lord" or p.role == "loyalist")))  then
              player.room:doIndicate(player.id, {p.id})
              AimGroup:cancelTarget(data,p.id)
              over = true
            end
        end
      else
        for _, pid in ipairs(origin_targets) do
          if over then break end
          local p = room:getPlayerById(pid)
            if ((player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist")))  then
              player.room:doIndicate(player.id, {p.id})
              AimGroup:cancelTarget(data,p.id)
              over = true
            end
        end
      end
    end
  end,
}
local jiutian = fk.CreateTriggerSkill{
  name = "water__jiutian",
  anim_type = "control",
  frequency = Skill.Compulsory,
  events = {fk.EventPhaseStart},
  can_trigger = function(self, event, target, player, data)
    local room = player.room
    if target == player and player:hasSkill(self) and player.phase == Player.Start then
      for _, p in ipairs(room.alive_players) do
        if ((player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist"))) and not p:isKongcheng() then
          local cids = p.player_cards[Player.Hand]
          local suits = {}
          for _, cid in ipairs(cids) do
            local c = Fk:getCardById(cid)
            if not table.contains(suits,c.suit) then
              table.insertIfNeed(suits,c.suit)
            end
          end
          if #suits > 2 then
            return true
          end
        end
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local getcards = {}
    local getsuits = {}
    local damage = true
    local targets = {}
    for _, p in ipairs(room.alive_players) do
      if ((player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist"))) and not p:isKongcheng() then
        local cids = p.player_cards[Player.Hand]
        local suits = {}
        for _, cid in ipairs(cids) do
          local c = Fk:getCardById(cid)
          if not table.contains(suits,c.suit) then
            table.insertIfNeed(suits,c.suit)
          end
        end
        if #suits > 2 then
          table.insertIfNeed(targets,p)
          local get = false
          for _, cid in ipairs(cids) do
            if get then break end
            local c = Fk:getCardById(cid)
            if not table.contains(getsuits,c.suit) then
              table.insertIfNeed(getsuits,c.suit)
              table.insertIfNeed(getcards,c.id)
              get = true
            end
          end
          if not get then
            table.insertIfNeed(getcards,table.random(cids,1))
            damage = false
          end
        end
      end
    end
    if #getcards > 0 then
      room:moveCardTo(getcards,player.Hand,player,fk.ReasonPrey)
      if damage then
        player:showCards(getcards)
        for _, p in ipairs(targets) do
          room:damage({
            from = player,
            to = p,
            damage = 1,
            damageType = fk.NormalDamage,
            skillName = self.name,
          })
        end
      end
    end
  end,
}

local xuanlie = fk.CreateTriggerSkill{
  name = "water__xuanlie",
  anim_type = "offensive",
  frequency = Skill.Compulsory,
  events = {fk.TurnEnd,fk.AfterCardsMove},
  can_trigger = function(self, event, target, player, data)
    if event == fk.AfterCardsMove then
      if player:hasSkill(self) then
          if player.phase ~= Player.NotActive  then
            for _, move in ipairs(data) do
              return move.to == player.id and move.from and  ((player.role == "rebel" and player.room:getPlayerById(move.from).role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (player.room:getPlayerById(move.from).role ~= "lord" and player.room:getPlayerById(move.from).role ~= "loyalist"))) and move.toArea == Player.Hand and player.room:getPlayerById(move.from):getMark("water__xuanlie-turn") == 0
            end
          end
      end
    elseif event == fk.TurnEnd and  target == player and player:hasSkill(self)then
      for _, p in ipairs(player.room.alive_players) do
        if ((player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist"))) and p:getMark("water__xuanlie-turn") > 0 then
          return true
        end
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.AfterCardsMove then
      for _, move in ipairs(data) do
        if ((player.role == "rebel" and player.room:getPlayerById(move.from).role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (player.room:getPlayerById(move.from).role ~= "lord" and player.room:getPlayerById(move.from).role ~= "loyalist")))   then
          room:setPlayerMark(player.room:getPlayerById(move.from),"water__xuanlie-turn",1)
        end
      end
    elseif event == fk.TurnEnd then
      for _, p in ipairs(player.room.alive_players) do
        if player.dead then break end
        if ((player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist"))) and p:getMark("water__xuanlie-turn") > 0 then
          room:damage({
            from = player,
            to = p,
            damage = 1,
            damageType = fk.NormalDamage,
            skillName = self.name,
          })
        end
      end
    end
  end,
}
xuannv:addSkill(dishi)
xuannv:addSkill(jiutian)
xuannv:addSkill(xuanlie)
xuannv:addSkill("water__shenqu")
Fk:loadTranslationTable{
  ["langchao__xuannv"] = "玄女",

  ["water__dishi"] = "帝师",
  [":water__dishi"] = "当一名角色使用【杀】或普通锦牌指定目标时，若目标数:为1，你可以为其增加目标；大于1，你可以为其减少目标。",
  ["water__jiutian"] = "九天",
  [":water__jiutian"] = "锁定技，准备阶段，若敌方角色有超过两种不同花色的手牌，则你获得其一张手牌。若你以此法获得的所有牌的花色均不同，则对所有你以此法获得其牌的敌方角色造成1点伤害。",
  ["water__xuanlie"] = "玄烈",
  [":water__xuanlie"] = "锁定技，回合结束时，对所有本回合你获得过其牌的敌方角色依次造成1点伤害。",

  ["$water__dishi"] = "慈航化众生，司南引轩辕。",
  ["$water__jiutian"] = "天上九宫十二城，仙云袅袅授长生。",
  ["$water__xuanlie"] = "碧霄一鹤引霞至，玄女箜篌九天来。",
  ["$water__shenqu_langchao__xuannv"] = "宝体天赐，触之必溃。",
  ["~langchao__xuannv"] = "世间何来两全法,不负仙侣不负卿。",
}

local shaohao = General(extension, "langchao__shaohao","god",16)
shaohao.hidden=true
local shenen = fk.CreateTriggerSkill{
  name = "water__shenen",
  anim_type = "control",
  mute = true,
  frequency = Skill.Compulsory,
  events = {fk.DamageFinished},
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self) then
      if not data.dealtRecorderId then return true end
      if data.extra_data and data.extra_data.shenen_maxDamage then
        if data.damage == 0 and  data.extra_data.shenen_maxDamage > 0 then
          if data.extra_data.shenen_ss and data.extra_data.shenen_zc then
            local p = data.extra_data.shenen_ss
            local p2 = data.extra_data.shenen_zc
            if ((player.role == "rebel" and p.role == player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role == "lord" or p.role == "loyalist"))) 
            and ((player.role == "rebel" and p2.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p2.role ~= "lord" and p2.role ~= "loyalist"))) then
              return not ( data.skillName and data.skillName == self.name)
            end
          end
        end
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local p = data.extra_data.shenen_ss or 0
    local p2 = data.extra_data.shenen_zc or 0
    if p and ((player.role == "rebel" and p.role == player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role == "lord" or p.role == "loyalist"))) 
    and p2 and ((player.role == "rebel" and p2.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p2.role ~= "lord" and p2.role ~= "loyalist")))then
      player.room:notifySkillInvoked(player,self.name,"offensive")
    player.room:damage({
      from = data.extra_data.shenen_ss,
      to = data.extra_data.shenen_zc,
      damage = 1,
      damageType = fk.NormalDamage,
      skillName = self.name,
    })
    end
  end,

  refresh_events = {fk.AfterSkillEffect, fk.SkillEffect},
  can_refresh = function (self, event, target, player, data)
    return player == player.room.players[1]
  end,
  on_refresh = function(self, event, target, player, data)
    local e = player.room.logic:getCurrentEvent():findParent(GameEvent.Damage, true)
    
    if e then
      local dat = e.data[1]
      dat.extra_data = dat.extra_data or {}
      dat.extra_data.shenen_maxDamage = dat.extra_data.shenen_maxDamage or 0
      dat.extra_data.shenen_maxDamage = math.max(dat.damage, dat.extra_data.shenen_maxDamage)
      dat.extra_data.shenen_ss = dat.to
      dat.extra_data.shenen_zc = dat.from
    end
  end,
}
local shenen_trigger = fk.CreateTriggerSkill{
  name = "#shenen_trigger",
  anim_type = "special",
  frequency = Skill.Compulsory,
  events = {fk.DamageCaused},
  can_trigger = function(self, event, target, player, data)
    return target and player:hasSkill(self) and ((player.role == "rebel" and target.role == player.role) or ((player.role == "lord" or player.role == "loyalist") and (target.role == "lord" or target.role == "loyalist"))) and data.damageType == fk.NormalDamage
  end,
  on_use = function(self, event, target, player, data)
    data.damageType = table.random({fk.FireDamage,fk.ThunderDamage})
  end,
}
local shenen_distance = fk.CreateDistanceSkill{
  name = "#water__shenen_distance",
  correct_func = function(self, from, to)
    for _, p in ipairs(Fk:currentRoom().alive_players) do
      if p:hasSkill(self) and ((from.role == "rebel" and p.role == from.role) or ((from.role == "lord" or from.role == "loyalist") and (p.role == "lord" or p.role == "loyalist"))) then
        return -999
      end
    end
  end,
}
local shenen_maxcards = fk.CreateMaxCardsSkill{
  name = "#water__shenen_maxcards",
  correct_func = function(self, player)
      for _, p in ipairs(Fk:currentRoom().alive_players) do
        if p:hasSkill(self) and ((player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist"))) then
          return 1
        end
      end
  end,
}
local baiyi = fk.CreateTriggerSkill{
  name = "water__baiyi",
  anim_type = "control",
  frequency = Skill.Compulsory,
  events = {fk.DrawNCards,fk.RoundStart,fk.DamageInflicted,fk.DamageCaused},
  can_trigger = function(self, event, target, player, data)
    local room = player.room
    local r = room:getTag("RoundCount")
    if (r//10)%2 == 0 then
      if event == fk.DrawNCards then
        return target and player:hasSkill(self) and ((player.role == "rebel" and target.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (target.role ~= "lord" and target.role ~= "loyalist"))) 
      elseif event == fk.RoundStart then
        return  player:hasSkill(self) and r%10 == 5
      elseif event == fk.DamageInflicted then
        return target and player:hasSkill(self) and ((player.role == "rebel" and target.role == player.role) or ((player.role == "lord" or player.role == "loyalist") and (target.role == "lord" or target.role == "loyalist"))) and data.damageType == fk.ThunderDamage
      elseif event == fk.DamageCaused then
        return target and player:hasSkill(self) and ((player.role == "rebel" and target.role == player.role) or ((player.role == "lord" or player.role == "loyalist") and (target.role == "lord" or target.role == "loyalist")))  and data.damageType == fk.FireDamage
      end
    else
      if event == fk.DrawNCards then
        return target and player:hasSkill(self) and ((player.role == "rebel" and target.role == player.role) or ((player.role == "lord" or player.role == "loyalist") and (target.role == "lord" or target.role == "loyalist"))) 
      elseif event == fk.RoundStart then
        return  player:hasSkill(self) and r%10 == 5
      elseif event == fk.DamageInflicted then
        return target and player:hasSkill(self) and ((player.role == "rebel" and target.role == player.role) or ((player.role == "lord" or player.role == "loyalist") and (target.role == "lord" or target.role == "loyalist"))) and data.damageType == fk.FireDamage
      elseif event == fk.DamageCaused then
        return target and player:hasSkill(self) and ((player.role == "rebel" and target.role == player.role) or ((player.role == "lord" or player.role == "loyalist") and (target.role == "lord" or target.role == "loyalist")))  and data.damageType == fk.ThunderDamage
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local r = room:getTag("RoundCount")
    if (r//10)%2 == 0 then
      if event == fk.DrawNCards then
        data.n = data.n - 1
      elseif event == fk.RoundStart then
      for _, p in ipairs(room.alive_players) do
        if ((player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist"))) then
          room:damage({
            from = player,
            to = p,
            damage = 1,
            damageType = fk.FireDamage,
            skillName = self.name,
          })
        end
      end
      end
    else
      if event == fk.DrawNCards then
        data.n = data.n + 1
      elseif event == fk.RoundStart then
      for _, p in ipairs(room.alive_players) do
        if ((player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist"))) then
          room:damage({
            from = player,
            to = p,
            damage = 1,
            damageType = fk.ThunderDamage,
            skillName = self.name,
          })
        end
      end
      end
    end
    if event == fk.DamageInflicted then
      return true 
    elseif event == fk.DamageCaused then
      data.damage = data.damage + 1
    end
  end,
}
shenen:addRelatedSkill(shenen_trigger)
shenen:addRelatedSkill(shenen_distance)
shenen:addRelatedSkill(shenen_maxcards)
shaohao:addSkill(shenen)
shaohao:addSkill(baiyi)
Fk:loadTranslationTable{
  ["langchao__shaohao"] = "少昊",

  ["water__shenen"] = "神恩",
  [":water__shenen"] = "锁定技，己方角色使用牌无距离限制且造成的普通伤害转化为随机属性伤害。敌方角色手牌上限+1。当己方角色受到来自敌方角色的伤害被防止时，其对原伤害来源造成一点伤害。",
  ["water__baiyi"] = "白仪",
  [":water__baiyi"] = "锁定技，<br>若当前轮次十位数为偶数，敌方角色摸牌阶段少摸一张牌；己方造成火焰伤害时伤害+1且防止受到的雷电伤害；当轮次个位数为5的轮次开始时，对所有敌方角色各造成一点火焰伤害。"..
  "<br>若当前轮次十位数为奇数，己方角色的摸牌阶段多摸一张牌；己方造成雷电伤害时伤害+1且防止受到的火焰伤害；当轮次个位数为5的轮次开始时，对所有敌方角色各造成一点雷电伤害。",

  ["#shenen_trigger"] = "神恩",
}


local hanba = General(extension, "langchao__hanba","god",16,16,General.Female)
hanba.hidden=true
local fenshi = fk.CreateTriggerSkill{
  name = "water__fenshi",
  anim_type = "offensive",
  frequency = Skill.Compulsory,
  events = {fk.EventPhaseStart},
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and player.phase == Player.Start and player:getHandcardNum() ~= player.hp
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if player:getHandcardNum() < player.hp then
      player:drawCards(player.hp - player:getHandcardNum(),self.name)
    elseif player:getHandcardNum() > player.hp then
      local n = player:getHandcardNum() - player.hp
      local tar = {}
      for _, p in ipairs(room.alive_players) do
        if ((player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist"))) then
          table.insertIfNeed(tar,p)
        end
      end
      local m = #tar
      local dam = {}
      for i = 1, m, 1 do
        if i == m then
          dam[i] = n
        else
          dam[i] = math.random(0,n)
          n = n - dam[i]
        end
      end
      for i = 1,m ,1 do
        room:damage({
          from = player,
          to = tar[i],
          damage = dam[i],
          damageType = fk.NormalDamage,
          skillName = self.name,
        })
      end
    end
  end,
}
local zhiri = fk.CreateTriggerSkill{
  name = "water__zhiri",
  anim_type = "offensive",
  frequency = Skill.Compulsory,
  events = {fk.TargetConfirmed},
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self) and ((player.role == "rebel" and target.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (target.role ~= "lord" and target.role ~= "loyalist"))) and data.card and data.card.color == Card.Red and data.card.type == Card.TypeTrick and data.firstTarget
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if not player.dead then
      player:drawCards(3,self.name)
    end
  end,
}
local xinji = fk.CreateTriggerSkill{
  name = "water__xinji",
  anim_type = "support",
  events = {fk.AfterCardsMove},
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self) and player.phase == Player.NotActive then
      local room = player.room
      for _, move in ipairs(data) do
        if move.moveReason == fk.ReasonDiscard  then
          if move.from  then
            for _, info in ipairs(move.moveInfo) do
              if info.fromArea == Card.PlayerHand then
                return move.from == player.id and not player.dead and ((player.role == "rebel" and player.room.current.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (player.room.current.role ~= "lord" and player.room.current.role ~= "loyalist")))
              end
            end
          end
        end
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    room:damage({
      from = player,
      to = player.room.current,
      damage = 1,
      damageType = fk.NormalDamage,
      skillName = self.name,
    })
  end,
}
hanba:addSkill(fenshi)
hanba:addSkill(zhiri)
hanba:addSkill(xinji)
Fk:loadTranslationTable{
  ["langchao__hanba"] = "旱魃",

  ["water__fenshi"] = "焚世",
  [":water__fenshi"] = "锁定技，准备阶段，若你的手牌数小于体力值，则将手牌摸至于体力值相等；若你的手牌数大于体力值，则你对敌方角色造成共计X点伤害，点数随机分配（X为手牌数减体力值）。",
  ["water__zhiri"] = "炙日",
  [":water__zhiri"] = "锁定技，当敌方角色使用红色锦囊牌指定目标后，你摸三张牌。",
  ["water__xinji"] = "心悸",
  [":water__xinji"] = "锁定技，当你于回合外因弃置而失去手牌时，若当前回合角色是敌方角色，你对其造成1点伤害。",

  ["$water__fenshi1"] = "业火燎原，焚天灭地。",
  ["$water__fenshi2"] = "骄阳似火，万物无生。",
  ["$water__zhiri1"] = "你以为，这样就已经结束了？",
  ["$water__zhiri2"] = "好舒服，这太阳的力量。",
  ["$water__xinji1"] = "人人心中，都有一团欲望之火。",
  ["$water__xinji2"] = "让心中之火，慢慢吞噬你吧！哈哈哈哈~",
  ["~langchao__hanba"] = "应龙，是你在呼唤我吗？",
}

local caoe = General(extension, "langchao__caoe","god",16,16,General.Female)
caoe.hidden=true
local shoujiang = fk.CreateTriggerSkill{
  name = "water__shoujiang",
  anim_type = "defensive",
  frequency = Skill.Compulsory,
  events = {fk.DamageInflicted},
  can_trigger = function(self, event, target, player, data)
    if target == player and player:hasSkill(self)  then
      return  data.damage > 1 and player:usedSkillTimes(self.name, Player.HistoryTurn) == 0 
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
      data.damage = 1
      if not player.dead then
        local cards = room:getCardsFromPileByRule(".|.|.|.|.|trick",3,"allPiles")
      if #cards > 0 then
      room:moveCards({
        ids = cards,
        to = player.id,
        toArea = Card.PlayerHand,
        moveReason = fk.ReasonJustMove,
        proposer = player.id,
        skillName = self.name,
      })
      end
      end
  end,
}
local luoshen = fk.CreateTriggerSkill{
  name = "water__luoshen",
  anim_type = "drawcard",
  events = {fk.EventPhaseStart},
  can_trigger = function(self, event, target, player, data)
    return target == player and player.phase == Player.Start and player:hasSkill(self)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    while true do
      local judge = {
        who = player,
        reason = self.name,
        pattern = ".|.|spade,club",
      }
      room:judge(judge)
      local cards = room:getCardsFromPileByRule(".|.|.|.|.|trick",2,"allPiles")
      if #cards > 0 then
      room:moveCards({
        ids = cards,
        to = player.id,
        toArea = Card.PlayerHand,
        moveReason = fk.ReasonJustMove,
        proposer = player.id,
        skillName = self.name,
      })
      room:setCardMark(Fk:getCardById(cards[1]), "@@water__luoshen-inhand-turn", 1)
      room:setCardMark(Fk:getCardById(cards[2]), "@@water__luoshen-inhand-turn", 1)
      end
      if judge.card.color ~= Card.Black then
        break
      end
      if not room:askForSkillInvoke(player, self.name) then
        break
      end
    end
  end,
}
local luoshen_max = fk.CreateMaxCardsSkill{
  name = "#water__luoshen_max",
  exclude_from = function(self, player, card)
    return card:getMark("@@water__luoshen-inhand-turn") > 0
  end,
}
luoshen:addRelatedSkill(luoshen_max)
caoe:addSkill(shoujiang)
caoe:addSkill("mashu")
caoe:addSkill(luoshen)
caoe:addSkill("ex__biyue")
caoe:addSkill("jizhi")
caoe:addSkill("guose")
Fk:loadTranslationTable{
  ["langchao__caoe"] = "曹娥",

  ["water__shoujiang"] = "守江",
  [":water__shoujiang"] = "锁定技，每回合限一次，当你受到伤害时，若该伤害大于1点，则此伤害变为1点（防止多余的伤害），然后你从牌堆或弃牌堆获得三张锦囊牌。",
  ["water__luoshen"] = "洛神",
  [":water__luoshen"] = "准备阶段开始时，你可以进行判定，然后从牌堆或弃牌堆中获得两张锦囊牌，若判定结果为黑，则你可重复此流程。你以此法获得的牌在本回合不计入手牌上限。",
  ["@@water__luoshen-inhand-turn"] = "洛神",

  ["$water__shoujiang"] = "沿江号哭悲，昼夜不绝声。",
  ["$ex__biyue_langchao__caoe"] = "月昏星暗，何人爱怜。",
  ["$water__luoshen"] = "清波川洛，江涛无声。",
  ["$jizhi_langchao__caoe"] = "结草衔环，孝感动天。",
  ["$guose_langchao__caoe"] = "娇花碧玉，明眸齿白。",
  ["~langchao__caoe"] = "父亲，这江水好冷~",
}

local taoshen = General(extension, "langchao__taoshen","god",16)
taoshen.hidden=true
local nutao = fk.CreateTriggerSkill{
  name = "water__nutao",
  anim_type = "offensive",
  frequency = Skill.Compulsory,
  events = {fk.TargetSpecified, fk.Damage},
  can_trigger = function(self, event, target, player, data)
    if target == player and player:hasSkill(self) then
      if event == fk.TargetSpecified then
        return data.card.type == Card.TypeTrick and data.firstTarget and
          table.find(AimGroup:getAllTargets(data.tos), function(id) return id ~= player.id end)
      else
        return player.phase == Player.Play and data.damageType == fk.ThunderDamage
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.TargetSpecified then
      local targets = table.filter(AimGroup:getAllTargets(data.tos), function(id)
        return id ~= player.id and not room:getPlayerById(id).dead end)
      local to = room:getPlayerById(table.random(targets))
      room:doIndicate(player.id, {to.id})
      room:damage{
        from = player,
        to = to,
        damage = 1,
        damageType = fk.ThunderDamage,
        skillName = self.name,
      }
    else
      room:addPlayerMark(player, "@water__nutao-phase", 1)
    end
  end,
}
local nutao_targetmod = fk.CreateTargetModSkill{
  name = "#water__nutao_targetmod",
  residue_func = function(self, player, skill, scope, card, to)
    if card and card.trueName == "slash" and player:getMark("@water__nutao-phase") > 0 and scope == Player.HistoryPhase then
      return player:getMark("@water__nutao-phase")
    end
  end,
}
local xiongzi = fk.CreateTriggerSkill{
  name = "water__xiongzi",
  anim_type = "drawcard",
  frequency = Skill.Compulsory,
  events = {fk.DrawNCards},
  can_trigger = function(self, event, target, player, data)
    if target == player and player:hasSkill(self)  then
      return  true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local n = #room.alive_players
    if table.every(room.alive_players, function(p) return p:getHandcardNum() >= player:getHandcardNum() end) then
      n = 2*n
    end
    data.n = data.n +  n
  end,
}
nutao:addRelatedSkill(nutao_targetmod)
taoshen:addSkill(nutao)
taoshen:addSkill(xiongzi)
taoshen:addSkill("mashu")
taoshen:addSkill("longdan")
taoshen:addSkill("wushuang")
Fk:loadTranslationTable{
  ["langchao__taoshen"] = "涛神",

  ["water__nutao"] = "怒涛",
  [":water__nutao"] = "锁定技，当你使用锦囊牌指定其他角色为目标时，随机对其中一个目标造成一点雷电伤害；<br>你于出牌阶段每造成一点雷电伤害，此阶段出【杀】次数+1。",
  ["@water__nutao-phase"] = "怒涛",
  ["water__xiongzi"] = "雄姿",
  [":water__xiongzi"] = "锁定技，摸牌阶段，你多摸X张牌，如果手牌数为全场最少，则改为多摸2*X张牌。(X为场上存活人数)",


  ["$water__nutao"] = "无序怒涛，奔流不灭。",
  ["$longdan_langchao__taoshen"] = "波澜逆转，攻守皆可。",
  ["$wushuang_langchao__taoshen"] = " 波涛怒天，神力无边。",
  ["$water__xiongzi"] = "智勇深沉，一世之雄。",
  ["~langchao__taoshen"] = "马革裹尸，身沉江心。",
}

local hebo = General(extension, "langchao__hebo","god",16)
hebo.hidden=true
local zhangchuan = fk.CreateTriggerSkill{
  name = "water__zhangchuan",
  anim_type = "control",
  frequency = Skill.Compulsory,
  events = {"fk.chuan"},
  can_trigger = function(self, event, target, player, data)
   if event == "fk.chuan" then
      local n = player:getMark("@water__chuan")
      return player:hasSkill(self) and ( n%4 == 0 or n%5 == 0 or n > 100 )
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == "fk.chuan" then
      local n = player:getMark("@water__chuan")
      if n%4 == 0 then
        if not player.dead then
          player:drawCards(1,self.name)
        end
      end
      if n%5 == 0 then
        local targets = {}
        for _, p in ipairs(room.alive_players) do
          if not p:isNude() and p.role ~= "renegade" and ((player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist"))) then
            table.insertIfNeed(targets,p)
          end
        end
        if #targets > 0 then
            local cards = table.random(targets):getCardIds("he")
            room:moveCardTo(table.random(cards),Card.DiscardPile,player,fk.ReasonDiscard)
        end
      end
      if n > 100 then
        room:setPlayerMark(player,"@water__chuan",0)
        local cards = {}
        for _, p in ipairs(room:getOtherPlayers(player)) do
          if not p:isKongcheng() then
            table.insertTable(cards,p:getCardIds("h"))
          end
        end
        if #cards > 0 then
          if player:getHandcardNum() < 100 then
            local cards2 = table.random(cards,(100 - player:getHandcardNum()))
            room:moveCardTo(cards2,Card.PlayerHand,player,fk.ReasonPrey,self.name)
            cards = table.filter(cards, function(id) return room:getCardArea(id) == Card.PlayerHand and room:getCardOwner(id) ~= player end)
            room:moveCardTo(cards,Card.DiscardPile,player,fk.ReasonDiscard,self.name)
          else
            room:moveCardTo(cards,Card.DiscardPile,player,fk.ReasonDiscard,self.name)
          end
        end
      end
    end
  end,
  refresh_events = {fk.AfterCardsMove},
  can_refresh = function(self, event, target, player, data)
    if event == fk.AfterCardsMove and player:hasSkill(self) and not player.dead then
      local n = 0
        for _, move in ipairs(data) do
          for _, info in ipairs(move.moveInfo) do
            if  move.toArea == Card.DiscardPile then
              n = n + 1
            end
          end
        end
      self.cost_data = n
      return n > 0
    end
  end,
  on_refresh = function(self, event, target, player, data)
    local room = player.room
    if event == fk.AfterCardsMove then
      for i = 1, self.cost_data, 1 do
        room:addPlayerMark(player,"@water__chuan",1)
        room.logic:trigger("fk.chuan", player, { name = "@water__chuan", num = 1})
      end
    end
  end,
}
local zunqing = fk.CreateTriggerSkill{
  name = "water__zunqing",
  mute = true,
  frequency = Skill.Compulsory,
  events = {fk.DamageCaused,fk.PreHpRecover},
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and ((event == fk.DamageCaused and player:getMark("@water__chuan") >= 20)or (event == fk.PreHpRecover and player:getMark("@water__chuan") >= 40))
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.DamageCaused then
      player:broadcastSkillInvoke(self.name)
      room:notifySkillInvoked(player,self.name,"offensive")
      data.damage = data.damage + 1
    elseif event == fk.PreHpRecover then
      player:broadcastSkillInvoke(self.name)
      room:notifySkillInvoked(player,self.name,"support")
      data.num = data.num + 2
    end
  end,
}
local xiaozi = fk.CreateTriggerSkill{
  name = "water__xiaozi",
  anim_type = "drawcard",
  frequency = Skill.Compulsory,
  events = {fk.DrawNCards},
  can_trigger = function(self, event, target, player, data)
    if target == player and player:hasSkill(self)  then
      return  player:getMark("@water__chuan") >= 10
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local n = player:getMark("@water__chuan")
    n = (n%100)//10
    data.n = data.n +  n
  end,
}
hebo:addSkill(zhangchuan)
hebo:addSkill(zunqing)
hebo:addSkill(xiaozi)
Fk:loadTranslationTable{
  ["langchao__hebo"] = "河伯",

  ["water__zhangchuan"] = "掌川",
  [":water__zhangchuan"] = "锁定技，每当一张牌进入弃牌堆后，你获得一个“川”标记；当“川”标记数达到4的倍数时，你摸一张牌；当“川”标记数达到5的倍数时，你随机弃置一名敌方角色的牌；当“川”标记数超过100时，你弃置所有“川”标记，然后你获得所有其他角色手牌(你最多以此法让手牌获得至为100张，超过100张则改为置入弃牌堆)。",
  ["water__zunqing"] = "尊清",
  [":water__zunqing"] = "锁定技，你的“川”标记数达到20时，你造成伤害值+1；你的“川”标记数达到40时，你回复体力值+2。",
  ["water__xiaozi"] = "潇姿",
  [":water__xiaozi"] = "锁定技，你摸牌阶段多摸X张牌（X为你的“川”标记数的十位数）。",
  ["@water__chuan"] = "川",


  ["$water__zhangchuan"] = "本神覆手之间，可倾天下之江河湖海。",
  ["$water__zunqing"] = "尊太上三清，江海盈而则国成。",
  ["$water__xiaozi"] = "人间草莽之辈，安能识得仙人之风骨？",
  ["~langchao__hebo"] = "我本人间逍遥客，奈何漠水寒千秋。",
}

local yuershen = General(extension, "langchao__yuershen","god",16)
yuershen.hidden=true
local wanshe = fk.CreateTriggerSkill{
  name = "water__wanshe",
  mute = true,
  frequency = Skill.Compulsory,
  events = {fk.CardUsing,fk.CardResponding},
  can_trigger = function(self, event, target, player, data)
    return target and  player:hasSkill(self.name)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if player:getMark("@water__wanshe") ~= 0 and data.card:getTypeString() ~= player:getMark("@water__wanshe") then
        player:broadcastSkillInvoke(self.name)
      room:notifySkillInvoked(player,self.name,"control")
      local targets = {}
        for _, p in ipairs(room.alive_players) do
          if not p:isNude() and p.role ~= "renegade" and ((player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist"))) then
            table.insertIfNeed(targets,p)
          end
        end
        if #targets > 0 then
            local cards = table.random(targets):getCardIds("he")
            room:moveCardTo(table.random(cards),Card.DiscardPile,player,fk.ReasonDiscard)
        end
    end
    if data.card:getTypeString() ~= "notype" then room:setPlayerMark(player, "@water__wanshe", data.card:getTypeString()) end
  end,
}
local shanling = fk.CreateTriggerSkill{
  name = "water__shanling",
  anim_type = "defensive",
  frequency = Skill.Compulsory,
  events = {fk.Damaged},
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self.name) and data.damage > 1
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local judge = {
      who = player,
      reason = self.name,
      pattern = ".|.|heart,diamond,spade,club",
    }
    room:judge(judge)
    if judge.card.color == Card.Red and player:isWounded() then
      room:recover({
        who = player,
        num = 1,
        recoverBy = player,
        skillName = self.name
      })
    elseif judge.card.color == Card.Black and data.from then
      room:damage({
        from = player,
        to = data.from,
        damage = 1,
        damageType = fk.NormalDamage,
        skillName = self.name,
      })
    end
  end,
}
local xuntan = fk.CreateTriggerSkill{
  name = "water__xuntan",
  mute = true,
  frequency = Skill.Compulsory,
  events = {fk.HpRecover,"fk.xuntan"},
  can_trigger = function(self, event, target, player, data)
  if player.general ~= "langchao__yuershen" then return end
    if event == fk.HpRecover then
      return  target and player:hasSkill(self.name) 
    elseif event == "fk.xuntan" then
      return target == player and player:hasSkill(self) and player:getMark("water__xuntan") >= 5 and player.hp > 0 and player.room.current.hp > 0
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.HpRecover then
      room:addPlayerMark(player,"water__xuntan",data.num)
      room.logic:trigger("fk.xuntan", player, { name = "water__xuntan", num = data.num})
    elseif event == "fk.xuntan" then
      if player.hp < 1 then return end
        player:broadcastSkillInvoke(self.name)
      room:notifySkillInvoked(player,self.name,"special")
        room:setPlayerMark(player,"water__xuntan",0)
        player:gainAnExtraTurn(true)
        room.logic:breakTurn()
    end
  end,
}
yuershen:addSkill(wanshe)
yuershen:addSkill(shanling)
yuershen:addSkill(xuntan)
Fk:loadTranslationTable{
  ["langchao__yuershen"] = "于儿神",

  ["water__wanshe"] = "挽蛇",
  [":water__wanshe"] = "锁定技，当有角色使用或打出一张牌时，若此牌与上一张使用或打出的牌类型不同，你随机弃置敌方角色的一张牌。",
  ["water__shanling"] = "闪鳞",
  [":water__shanling"] = "锁定技，当你受到大于1点的伤害后，你进行判定：若为红，你回复一点体力；若为黑，伤害来源受到一点伤害。(仅对于儿神生效)",
  ["water__xuntan"] = "巡潭",
  [":water__xuntan"] = "锁定技，每当场上角色累计回复5点体力时，你立即获得一个额外回合。",
  ["@water__wanshe"] = "挽蛇",
  ["@water__xuntan"] = "巡潭",



  ["$water__wanshe"] = "灵蛇待捕，欲以诸君之身为饲饵。",
  ["$water__shanling"] = "",
  ["$water__xuntan"] = "江海相连，居小潭可辩天下之水文。",
  ["~langchao__yuershen"] = "魂陨江海，所愿皆覆浪涛",
}

local yanwang = General(extension, "langchao__yanluowang","god",16)
yanwang.hidden=true
local tiemian = fk.CreateTriggerSkill{
  name = "water__tiemian",
  frequency = Skill.Compulsory,
  events = {fk.TargetConfirmed},
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and data.card and data.card.trueName == "slash" and data.card.color and data.card.color == Card.Red and math.random(1,4) <= 3
  end,
  on_use = function(self, event, target, player, data)
      table.insertIfNeed(data.nullifiedTargets, player.id)
      return true
  end,
}
local difu = fk.CreateTriggerSkill{
  name = "water__difu",
  anim_type = "control",
  frequency = Skill.Compulsory,
  events = {fk.EventPhaseStart},
  can_trigger = function(self, event, target, player, data)
    return  player:hasSkill(self.name) and target:getHandcardNum() > target.hp and target.phase == Player.Play and ((player.role == "rebel" and target.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (target.role ~= "lord" and target.role ~= "loyalist")))
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local n = target:getHandcardNum() - target.hp
    if target:getHandcardNum() >= 50 then
      local cards = target:getCardIds("h")
      room:moveCardTo(table.random(cards,n),Card.DiscardPile,player,fk.ReasonDiscard)
    else
      room:askForDiscard(target,n,n,false,self.name,false)
    end
  end,
}
local zhennu = fk.CreateTriggerSkill{
  name = "water__zhennu",
  anim_type = "special",
  frequency = Skill.Compulsory,
  events = {fk.HpChanged},
  can_trigger = function(self, event, target, player, data)
     return  target == player and player:hasSkill(self.name) and player.hp <= player.maxHp//2 and player.hp > 0 and player:usedSkillTimes(self.name, Player.HistoryGame) == 0
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    player:gainAnExtraTurn(true)
    player:drawCards(4,self.name)
    room.logic:breakTurn()
  end,
}
local xingpan = fk.CreateTriggerSkill{
  name = "water__xingpan",
  anim_type = "control",
  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 judge = {
      who = player,
      reason = self.name,
      pattern = ".|.|heart,diamond,spade,club",
    }
    room:judge(judge)
    if judge.card.color == Card.Red  then
      local max = 0
      local tar
      for _, p in ipairs(room:getOtherPlayers(player)) do
        if not p:isKongcheng() and ((player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist"))) then
          if p:getHandcardNum() > max then
            max = p:getHandcardNum()
            tar = p
          end
        end
      end
      if max > 0 and tar then
        if max >= 50 then
          local cards = tar:getCardIds("h")
          if #cards > 0 then
            room:moveCardTo(table.random(cards,max//2),Card.PlayerHand,player,fk.ReasonPrey,self.name)
          end
        else
          local n = math.max(1,max//2)
          local cards = room:askForDiscard(tar,n,n,true,self.name,false,nil,"刑判：请选择将"..n.."张手牌交给 %dest 。::"..player.id,true)
          if #cards > 0 then
            room:moveCardTo(cards,Card.PlayerHand,player,fk.ReasonPrey,self.name)
          end
        end
      end
    elseif judge.card.color == Card.Black  then
      local max = 0
      local tar
      for _, p in ipairs(room:getOtherPlayers(player)) do
        if   ((player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist"))) then
          if p.hp > max then
            max = p.hp
            tar = p
          end
        end
      end
      if max > 0 and tar and not tar.dead then
        room:loseHp(tar,1,self.name)
      end
    end
  end,
}
local dianwei = fk.CreateTriggerSkill{
  name = "water__dianwei",
  anim_type = "offensive",
  frequency = Skill.Compulsory,
  events = {fk.EventPhaseStart},
  can_trigger = function(self, event, target, player, data)
    return  target == player and player:hasSkill(self) and player.phase == Player.Start
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    for _, p in ipairs(room.alive_players) do
      if p.dead or player.dead then return end
      if #p:getCardIds("e") == 0 and  ((player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist"))) then
        room:useVirtualCard("slash", nil, player, {p}, self.name)
      end
    end
    for _, p in ipairs(room.alive_players) do
      if p.dead or player.dead then return end
      if #p:getCardIds("e") > 0 and  ((player.role == "rebel" and p.role ~= player.role) or ((player.role == "lord" or player.role == "loyalist") and (p.role ~= "lord" and p.role ~= "loyalist"))) then
        local cards = p:getCardIds("e")
        room:moveCardTo(table.random(cards),Card.DiscardPile,player,fk.ReasonDiscard)
      end
    end
  end,
}
yanwang:addSkill(tiemian)
yanwang:addSkill(difu)
yanwang:addSkill(zhennu)
yanwang:addSkill(xingpan)
yanwang:addSkill(dianwei)
Fk:loadTranslationTable{
  ["langchao__yanluowang"] = "阎王",

  ["water__tiemian"] = "铁面",
  [":water__tiemian"] = "锁定技，当你被红色【杀】指定为目标时，有75%概率令此杀对你无效。",
  ["water__difu"] = "地府",
  [":water__difu"] = "锁定技，敌方角色的出牌阶段开始时，若其手牌数大于体力值，其弃置超出体力值的手牌数（若其手牌数大于50则改为随机弃置）。",
  ["water__zhennu"] = "震怒",
  [":water__zhennu"] = "锁定技，每局游戏限一次，当你的体力值降为体力上限的一半及以下时，你摸4张牌并立即执行一个额外的回合。",
  ["water__xingpan"] = "刑判",
  [":water__xingpan"] = "锁定技，出牌阶段开始时，你进行判定：<br>若为红色，手牌数最多的一名敌方角色将一半手牌交给你（若其手牌数大于50则改为随机选择）；<br>若为黑色，体力最多的一名敌方角色失去一点体力。",
  ["water__dianwei"] = "殿威",
  [":water__dianwei"] = "锁定技，准备阶段，你视为对所有装备区没牌的敌方角色依次使用一张【杀】，然后随机弃置装备区有牌的敌方角色一张装备区的牌。",
  ["#water__xingpan"] = "刑判：请选择将 %arg 张手牌交给 %dest 。",

  ["$water__tiemian"] = "铁面无私，秉公执法。",
  ["$water__difu"] = "进我地府者，为我所管。",
  ["$water__zhennu"] = "岂容汝等..恶鬼放肆。",
  ["$water__xingpan"] = "你的罪过，只能用刑场还。",
  ["$water__dianwei"] = "殿威。",
  ["~langchao__yanwang"] = "",

}


local kuangfeng = fk.CreateTriggerSkill{
  name ="langchao__kuangfeng",
  frequency = Skill.Compulsory,
  events = {"fk.starwave"},
  can_trigger = function(self, event, target, player, data)
      return player:hasSkill(self)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    room:changeShield(player,8)
    player:drawCards(4,self.name)
    local ps= table.filter(room:getOtherPlayers(player,nil,true), function(p) return p.id<0 and p.rest>0 end)
    if #ps==0 then return end
    local to=table.random(ps)
      room:setPlayerRest(to,0)
      room:revivePlayer(to, true, "rest")
    local aips= table.filter(room:getAllPlayers(), function(p) return p.id<0 and not p.dead end)
      if #aips==0 then return end
      for _, p in ipairs(aips) do
        room:addPlayerMark(p, "@jbskl_shengdun", 1)
      end
    
  end,
}

local haoling=fk.CreateTriggerSkill{
  name = "langchao__haoling",
  events = {fk.TurnStart},
  frequency = Skill.Compulsory,
  mute = true,
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self) then
      if event == fk.TurnStart then
        return target.id<0 and target.role~="lord" and target.general~="langchao__fengbaogoutouren" and target~=player
      end
    end
  end,

  on_use = function(self, event, target, player, data)
    local room = player.room
    player:chat("狂风，听我号令！")
    room:changeHero(target,"langchao__fengbaogoutouren", true, false, false, false)

  end,
}


aolajier:addSkill(kuangfeng)
aolajier:addSkill(haoling)
aolajier:addSkill("jbskl__tianyou")
--aolajier:addSkill()
Fk:loadTranslationTable{
  ["langchao__aolajier"] = "奥拉基尔",
  ["langchao__kuangfeng"]="狂风",
  ["langchao__haoling"]="号令",
  [":langchao__haoling"]="其他非首领机器人回合开始时，若不为风暴狗头人，将其变为风暴狗头人。",
  [":langchao__kuangfeng"]="锁定技，每次起浪时，获得8点护甲,摸4张牌，随机唤醒一个机器人,使所有机器人获得一层圣盾。",


}

local zhangbao=T.creategenandtanslatene({extension,"langchao__zhangbao","god",6},{"魔张宝","黄巾鬼士"})
local zhangliang=T.creategenandtanslatene({extension,"langchao__zhangliang","god",7},{"魔张梁","黄巾魔士"})
local zhangjiao=T.creategenandtanslatene({extension,"langchao__zhangjiao","god",10},{"魔张角","黄天当立"})
--local huaxiong=T.creategenandtanslatene({extension,"langchao__huaxiong","god",8},{"魔华雄","暗之先锋"})
--local zhangliao=T.creategenandtanslatene({extension,"langchao__zhangliao","god",9},{"魔张辽","虎门之魔神"})
--local diaochan=T.creategenandtanslatene({extension,"langchao__diaochan","god",9},{"魔貂蝉","邪灵之舞姬"})
--local lvbu=T.creategenandtanslatene({extension,"langchao__lvbu","god",18},{"魔吕布","堕落之战神"})

--local dongzhuo=T.creategenandtanslatene({extension,"langchao__dongzhuo","god",25},{"魔董卓","终焉之魔王"})
zhangjiao.total_hidden=true
local langchao__mohua = fk.CreateTriggerSkill{
  name = "langchao__mohua",
  anim_type = "special",
  frequency = Skill.Compulsory,
  events = {fk.HpChanged},
  can_trigger = function(self, event, target, player, data)
     return  target == player and player:hasSkill(self.name) and player.hp <= 0  and player:usedSkillTimes(self.name, Player.HistoryGame) == 0
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    room:recover({
      who = player,
      num = player.maxHp//2-player.hp,
      recoverBy = player,
      skillName = self.name
  })
    player:gainAnExtraTurn(true)
    player:drawCards(4,self.name)
    room.logic:breakTurn()
  end,
}

local sk__chengfeng = fk.CreateTriggerSkill{
  name = "langchao__chengfeng",
  anim_type = "special",
  frequency = Skill.Compulsory,
  events = {fk.DamageInflicted, fk.TurnEnd},
  can_trigger = function(self, event, target, player, data)
    if event == fk.DamageInflicted then
      return target == player and player:hasSkill(self)
    elseif event == fk.TurnEnd then
      return player:hasSkill(self) and player:getMark("@lc__chengfeng") > 1
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.DamageInflicted then
      local judge = {
        who = player,
        reason = self.name,
        pattern = ".",
      }
      room:judge(judge)
      if player.dead then return end
      if judge.card.suit == Card.Spade or judge.card.suit == Card.Club then
        room:addPlayerMark(player, "@lc__chengfeng", 1)
      else
        if data.damage==1 then
        data.damage = data.damage- 1
        else
          data.damage =  1
        end
      end
    elseif event == fk.TurnEnd then
      room:removePlayerMark(player, "@lc__chengfeng", 2)
      player:gainAnExtraTurn(true)
    end
  end,
}

local sk__yingbing = fk.CreateTriggerSkill{
  name = "langchao__yingbing",
  anim_type = "offensive",
  events = {fk.FinishJudge},
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self) and data.card.color == Card.Black and
      not player:isProhibited(target, Fk:cloneCard("thunder__slash")) 
  end,
  on_cost = function(self, event, target, player, data)
    return true
  end,
  on_use = function(self, event, target, player, data)
    local room=player.room
    local targets=pvetool:getenemy(player.room)
    if #target==0 then return end
      for _, p in ipairs(targets) do
        local to = room:getPlayerById(p)
        player.room:useVirtualCard("thunder__slash", nil, player, to, self.name, true)
      end
    
  end,
}

local sk__zhoufu = fk.CreateTriggerSkill{
  name = "lc__zhoufu",
  anim_type = "control",
  events = {fk.TurnStart},
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self) and target ~= player and not target.dead and target.id>0
  end,
  on_cost = function(self, event, target, player, data)

      return true
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if target.dead then return end
    local judge = {
      who = target,
      reason = self.name,
      pattern = ".|.|spade,club",
    }
    room:judge(judge)
    if target.dead then return end
    if judge.card.suit == Card.Spade then
      room:setPlayerMark(target, "@@lc__zhoufu-turn", 1)
    elseif judge.card.suit == Card.Club then
      room:askForDiscard(target, 2, 2, true, self.name, false)
    end
  end,
}
local sk__zhoufu_invalidity = fk.CreateInvaliditySkill {
  name = "#lc__zhoufu_invalidity",
  invalidity_func = function(self, from, skill)
    return from:getMark("@@lc__zhoufu-turn") > 0 and skill:isPlayerSkill(from)
  end
}


local jijun = fk.CreateTriggerSkill{
  name = "lc__jijun",
  events = {fk.AfterCardsMove},
  mute = true,
  can_trigger = function(self, event, target, player, data)
    if player.dead then return false end
    local ids = {}
    local room = player.room
    for _, move in ipairs(data) do
      if move.toArea == Card.DiscardPile and move.moveReason == fk.ReasonJudge then
        local judge_event = room.logic:getCurrentEvent():findParent(GameEvent.Judge)
        if judge_event and judge_event.data[1].who == player  then
          for _, info in ipairs(move.moveInfo) do
            if info.fromArea == Card.Processing and room:getCardArea(info.cardId) == Card.DiscardPile then
              table.insertIfNeed(ids, info.cardId)
            end
          end
        end
      end
    end
    ids = U.moveCardsHoldingAreaCheck(room, ids)
    if #ids > 0 then
      self.cost_data = ids
      return true
    end
  end,
  on_cost = Util.TrueFunc,
  on_use = function(self, event, target, player, data)
    local ids = table.simpleClone(self.cost_data) --理论上来讲只有一张
    player:addToPile("zhangliang_fang", self.cost_data, true, self.name)
  end,
}

local fangtong = fk.CreateTriggerSkill{
  name = "lc__fangtong",
  anim_type = "offensive",
  events = {fk.EventPhaseStart},
  can_trigger = function(self, _, target, player, _)
    if target == player and player:hasSkill(self) and player.phase == Player.Finish then
      local n = 0
      for _, id in ipairs(player:getPile("zhangliang__bing")) do
        n = n + Fk:getCardById(id).number
      end
      if n>=36 then
        self.cost_data = n 
        return true
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room=player.room
    local n=self.cost_data 
    local targets=pvetool:getenemy(player.room)
    if #target==0 then return end
      for _, p in ipairs(targets) do
        local to = room:getPlayerById(p)
        local x=#to.player_skills or 0
        room:damage{
          from = player,
          to = to,
          damage = n+x-36,
          skillName = self.name,
          damageType = fk.ThunderDamage,
        
        }
      end
  end,

}

sk__zhoufu:addRelatedSkill(sk__zhoufu_invalidity)
zhangbao:addSkill(sk__zhoufu)
zhangbao:addSkill(langchao__mohua)
zhangbao:addSkill(sk__yingbing)
zhangbao:addSkill(sk__chengfeng)
zhangliang:addSkill(jijun)
zhangliang:addSkill(fangtong)
zhangliang:addSkill("langchao__chengfeng")
zhangjiao:addSkill("langchao__chengfeng")

Fk:loadTranslationTable{
  ["@@lc__zhoufu-turn"]="咒缚",
  ["lc__jijun"] = "集军",
  [":lc__jijun"] = "当一名角色的判定的判定牌移至弃牌堆后，你可以将此判定牌置于你的武将牌上（称为“方”）。",
  ["#jijun_delay"] = "集军",
  ["lc__fangtong"] = "方统",
  [":lc__fangtong"] = "结束阶段,若所有“方”的点数之和大于36，你弃置所有“方”对所有玩家造成x点雷电伤害(x=玩家技能数+方点数和-36)",

}

T.skilltranslate("langchao__mohua",{"魔化",[[锁定技，每局游戏限一次，当你的体力不高于0时，你回复一半的体力并立即执行一个额外的回合。]]})
T.skilltranslate("langchao__yingbing",{"影兵",[[一名角色的黑色判定牌生效后，你视为对每一名玩家使用一张雷【杀】。]]})
T.skilltranslate("lc__zhoufu",{"咒缚",[[玩家的回合开始时，你令其进行判定，若结果为：♠，其本回合所有技能无效；♣，其弃置两张牌。]]})
T.skilltranslate("langchao__chengfeng",{"黄天",[[锁定技，当你受到伤害时，你判定：若结果不为黑色，你令此伤害改为1(若为1则令伤害-1)；若结果为黑色，你获得1枚“黄天”标记。
<br>一名角色的回合结束后，若“黄天”标记不少于2枚，你弃置2枚“黄天”标记并执行一个额外回合。]]})


T.tablestranslate(
  {"@lc__chengfeng",},
  {"黄天",}
)

return extension