local extension = Package:new("dingzhi")
extension.extensionName = "MahjongSoul"
extension.game_modes_blacklist = { "as_StonehengEarena_mode" }
Fk:loadTranslationTable {
  ["dingzhi"] = "小楼东风：华夏",
  ["dz"] = "华夏",
}
local U = require "packages/utility/utility"
local sunwu = General(extension, "dz__sunwu", "qun", 4)
Fk:loadTranslationTable {
  ["dz__sunwu"] = "孙武",
  ["designer:dz__sunwu"] = "小楼东风",
}
local dz_liangcao = fk.CreateTriggerSkill {
  name = "dz_liangcao",
  anim_type = "negative",
  events = { fk.EventPhaseChanging },
  can_trigger = function(self, event, target, player, data)
    if data.to == Player.Start then
      return player:hasSkill(self) and target == player
    elseif data.to == Player.Draw then
      return player:getMark("dz_liangcao_draw-turn") > 0
    elseif data.to == Player.Finish then
      return player:getMark("dz_liangcao_finish-turn") > 0
    end
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    if data.to == Player.Start then
      local choice = room:askForChoice(player, { "liangcao_shelie", "liangcao_mopai", "Cancel" }, self.name)
      self.cost_data = choice
      return true
    elseif data.to == Player.Finish or data.to == Player.Draw then
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if data.to == Player.Start then
      if self.cost_data == "liangcao_shelie" then
        room:addPlayerMark(player, "dz_liangcao_draw-turn", 1)
      elseif self.cost_data == "liangcao_mopai" then
        room:addPlayerMark(player, "dz_liangcao_finish-turn", 1)
      else
        return
      end
    elseif data.to == Player.Draw then
      local cards = room:getNCards(5)
      room:moveCards({
        ids = cards,
        toArea = Card.Processing,
        moveReason = fk.ReasonPut,
        skillName = self.name,
        proposer = player.id
      })
      local get = {}
      for _, id in ipairs(cards) do
        local suit = Fk:getCardById(id).suit
        if table.every(get, function(id2)
              return Fk:getCardById(id2).suit ~= suit
            end) then
          table.insert(get, id)
        end
      end
      get = room:askForArrangeCards(player, self.name, cards, "#shelie-choose", false, 0, { 5, 4 }, { 0, #get },
        ".", "shelie", { {}, get })[2]
      if #get > 0 then
        room:obtainCard(player, get, true, fk.ReasonPrey)
      end
      cards = table.filter(cards, function(id) return room:getCardArea(id) == Card.Processing end)
      if #cards > 0 then
        room:moveCardTo(cards, Card.DiscardPile, nil, fk.ReasonJustMove, self.name)
      end
      return true
    elseif data.to == Player.Finish then
      player:drawCards(3, self.name)
    end
  end,
}
sunwu:addSkill(dz_liangcao)
Fk:loadTranslationTable {
  ["dz_liangcao"] = "粮草",
  [":dz_liangcao"] = "准备阶段，你可以选择一项：<br>1.本回合摸牌阶段改为发动〖涉猎〗；<br>2.本回合结束阶段摸三张牌。",

  ["liangcao_shelie"] = "摸牌阶段发动〖涉猎〗",
  ["liangcao_mopai"] = "结束阶段摸三张牌",
}
local dz_silun = fk.CreateActiveSkill {
  name = "dz_silun",
  anim_type = "offensive",
  prompt = "#silun-active",
  card_num = 2,
  target_num = 0,
  can_use = Util.TrueFunc,
  card_filter = function(self, to_select, selected)
    return #selected < 2 and not Self:prohibitDiscard(Fk:getCardById(to_select))
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    room:throwCard(effect.cards, self.name, player, player)
    local suit1 = Fk:getCardById(effect.cards[1]).suit
    local suit2 = Fk:getCardById(effect.cards[2]).suit
    local ok = false
    if suit1 == Card.Heart and suit2 == Card.Heart then
      player:drawCards(3, self.name)
    elseif suit1 == Card.Diamond and suit2 == Card.Diamond then
      room:addPlayerMark(player, "@dz_silun_mianshang", 1)
    elseif suit1 == Card.Spade and suit2 == Card.Spade then
      if player:isWounded() then
        room:recover({
          who = player,
          num = 1,
          recoverBy = player,
          skillName = self.name
        })
      end
    elseif suit1 == Card.Club and suit2 == Card.Club then
      local ids = room:askForChoosePlayers(player, table.map(player.room.alive_players, function(p)
        return p.id
      end), 1, 1, "四轮：你可以对一名角色造成一点伤害", self.name, true)
      if #ids > 0 then
        if not room:getPlayerById(ids[1]).dead then
          room:damage {
            from = player,
            to = room:getPlayerById(ids[1]),
            damage = 1,
            skillName = self.name,
          }
        end
      end
    elseif suit1 == Card.Heart and suit2 == Card.Diamond or suit1 == Card.Diamond and suit2 == Card.Heart then
      room:setPlayerMark(player, "dz_silun-turn", "fire_attack")
      ok = true
    elseif suit1 == Card.Club and suit2 == Card.Diamond or suit1 == Card.Diamond and suit2 == Card.Club then
      room:setPlayerMark(player, "dz_silun-turn", "dismantlement")
      ok = true
    elseif suit1 == Card.Club and suit2 == Card.Spade or suit1 == Card.Spade and suit2 == Card.Club then
      room:setPlayerMark(player, "dz_silun-turn", "snatch")
      ok = true
    elseif suit1 == Card.Heart and suit2 == Card.Spade or suit1 == Card.Spade and suit2 == Card.Heart then
      room:setPlayerMark(player, "dz_silun-turn", "duel")
      ok = true
    end
    if ok == true then
      local success, data = room:askForUseActiveSkill(player, "dz_silun_viewas", "四论：请选择此牌的使用目标", true)
      if success then
        local ids = Fk.skills["dz_silun_viewas"]:viewAs(data.cards)
        local use = {
          from = player.id,
          tos = table.map(data.targets, function(id) return { id } end),
          card = ids,
          extraUse = true,
        }
        room:useCard(use)
      end
    end
  end
}
local dz_silun_trigger = fk.CreateTriggerSkill {
  name = "#dz_silun_trigger",
  events = { fk.DamageInflicted },
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    if not player:hasSkill("dz_silun") then return false end
    return target == player and player:getMark("@dz_silun_mianshang") > 0
  end,
  on_use = function(self, event, target, player, data)
    player.room:removePlayerMark(player, "@dz_silun_mianshang")
    return true
  end,
}
local dz_silun_viewas = fk.CreateViewAsSkill {
  name = "dz_silun_viewas",
  interaction = function()
    local name = {}
    local card = Self:getMark("dz_silun-turn")
    table.insert(name, card)
    if #name == 0 then return false end
    return UI.ComboBox { choices = name }
  end,
  card_filter = Util.FalseFunc,
  view_as = function(self, cards)
    if not self.interaction.data then return end
    local card = Fk:cloneCard(self.interaction.data)
    card.skillName = "dz_silun"
    return card
  end,
}
dz_silun:addRelatedSkill(dz_silun_trigger)
Fk:addSkill(dz_silun_viewas)
sunwu:addSkill(dz_silun)
Fk:loadTranslationTable {
  ["dz_silun"] = "四论",
  [":dz_silun"] = "出牌阶段，你可以弃置两张牌，根据弃置牌的花色执行以下效果：<br>" ..
      "均为红桃，你摸三张牌；<br>" ..
      "均为黑桃，你回复一点体力；<br>" ..
      "均为方块，防止你下一次受到的伤害；<br>" ..
      "均为梅花，你可以对一名角色造成一点伤害；<br>" ..
      "红桃/方块，视为使用【火攻】；<br>" ..
      "梅花/方块，视为使用【过河拆桥】；<br>" ..
      "梅花/黑桃，视为使用【顺手牵羊】；<br>" ..
      "红桃/黑桃，视为使用【决斗】。",

  ["#dz_silun_trigger"] = "四论",
  ["#silun-active"] = "你可以弃置两张牌，若达成条件可发动对应效果",

  ["dz_silun_viewas"] = "四论",
  ["@dz_silun_mianshang"] = "四论",
}
local fanzeng = General(extension, "dz__fanzeng", "qun", 3)
Fk:loadTranslationTable {
  ["dz__fanzeng"] = "范增",
  ["designer:dz__fanzeng"] = "小楼东风",
}
local dz_qiji = fk.CreateActiveSkill {
  name = "dz_qiji",
  anim_type = "offensive",
  prompt = "#dz_qiji-active",
  card_num = 0,
  target_num = 0,
  can_use = function(self, player, card, extra_data)
    return player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local cards = room:getNCards(5)
    player:addToPile("dz_qiji&", cards, true, self.name)
  end
}
local dz_qiji_discard = fk.CreateTriggerSkill {
  name = "#dz_qiji_discard",
  events = { fk.EventPhaseChanging },
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    if not player:hasSkill("dz_qiji") then return false end
    return target == player and data.to == Player.Finish and #player:getPile("dz_qiji&") > 0
  end,
  on_use = function(self, event, target, player, data)
    player.room:moveCards({
      from = player.id,
      ids = player:getPile("dz_qiji&"),
      toArea = Card.DiscardPile,
      moveReason = fk.ReasonPutIntoDiscardPile,
      skillName = self.name,
    })
  end,
}
dz_qiji:addRelatedSkill(dz_qiji_discard)
fanzeng:addSkill(dz_qiji)
Fk:loadTranslationTable {
  ["dz_qiji"] = "奇计",
  [":dz_qiji"] = "出牌阶段限一次，你可以将牌堆顶的五张牌置于武将牌上，你可以如手牌般使用或打出这些牌，若如此做，结束阶段，弃置这些牌。",

  ["#dz_qiji_discard"] = "奇计",
  ["#dz_qiji-active"] = "你可以将牌堆顶的五张牌置于武将牌上",
  ["dz_qiji&"] = "奇计",
}
local dz_hongmen = fk.CreateActiveSkill {
  name = "dz_hongmen",
  anim_type = "offensive",
  prompt = "#dz_hongmen-active",
  card_num = 1,
  target_num = 1,
  can_use = function(self, player, card, extra_data)
    return player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
  end,
  target_filter = function(self, to_select, selected, selected_cards, card, extra_data)
    return #selected == 0 and to_select ~= Self.id
  end,
  card_filter = function(self, to_select, selected)
    return #selected == 0
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local target = room:getPlayerById(effect.tos[1])
    local id = Fk:getCardById(effect.cards[1])
    room:fillAG(target, id)
    room:delay(1200)
    room:closeAG(target)
    local chs = { "hongmen_huode:::" .. id:toLogString() }
    if #target:getCardIds("hej") > 2 then
      table.insertIfNeed(chs, "hongmen_jiaogei:" .. player.id)
    end
    local lose = false
    local chc = room:askForChoice(target, chs, self.name, nil, nil,
      { "hongmen_huode:::" .. id:toLogString(), "hongmen_jiaogei:" .. player.id })
    if chc == "hongmen_jiaogei:" .. player.id then
      local cards = room:askForCardsChosen(target, target, 2, 2, "hej", self.name,
        "#dz_hongmen-askchos:" .. player.id .. "::" .. id:toLogString())
      room:obtainCard(player, cards, false, fk.ReasonPrey)
    else
      lose = true
    end
    if lose == true then
      room:obtainCard(target, effect.cards[1], false, fk.ReasonPrey)
      room:loseHp(target, 1)
    end
  end
}
fanzeng:addSkill(dz_hongmen)
Fk:loadTranslationTable {
  ["dz_hongmen"] = "鸿门",
  [":dz_hongmen"] = "出牌阶段限一次，你可以选择一张手牌令一名角色观看，其需选择交给你两张区域内的牌，或获得此牌然后失去一点体力。",

  ["#dz_hongmen-askchos"] = "鸿门：你需要交给 %src 两张牌，或点击取消失去一点体力并获得 %arg",
  ["#dz_hongmen-active"] = "选择一张牌和一名其他角色",
  ["hongmen_huode"] = "获得%arg，失去一点体力",
  ["hongmen_jiaogei"] = "交给%src区域内的两张牌",
}
local huoqubing = General(extension, "dz__huoqubing", "qun", 4)
Fk:loadTranslationTable {
  ["dz__huoqubing"] = "霍去病",
  ["designer:dz__huoqubing"] = "小楼东风",
}
local dz_benxi = fk.CreateTriggerSkill {
  name = "dz_benxi",
  anim_type = "control",
  events = { fk.CardUsing },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and data.card.trueName == "slash" and data.tos
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local targets = U.getUseExtraTargets(room, data)
    if #targets == 0 then return false end
    local tos = room:askForChoosePlayers(player, targets, 1, 1,
      "奔袭：请选择此【杀】的额外目标", self.name, true)
    if #tos > 0 then
      table.forEach(tos, function(id)
        table.insert(data.tos, { id })
      end)
    end
  end,
}
local dz_benxi_distance = fk.CreateDistanceSkill {
  name = "#dz_benxi_distance",
  frequency = Skill.Compulsory,
  correct_func = function(self, from, to)
    if from:hasSkill("dz_benxi") then
      return -1
    end
  end,
}
dz_benxi:addRelatedSkill(dz_benxi_distance)
huoqubing:addSkill(dz_benxi)
Fk:loadTranslationTable {
  ["dz_benxi"] = "奔袭",
  [":dz_benxi"] = "锁定技，你计算与其他角色的距离-1，使用【杀】可以额外指定一个目标。",
}
local dz_zhuixi = fk.CreateTriggerSkill {
  name = "dz_zhuixi",
  anim_type = "control",
  events = { fk.TargetSpecifying },
  can_trigger = function(self, event, target, player, data)
    for _, pid in ipairs(AimGroup:getAllTargets(data.tos)) do
      local p = player.room:getPlayerById(pid)
      if p:getMark("@zhuixi-turn") > 1 then
        return target == player and player:hasSkill(self) and data.card
      end
    end
  end,
  on_cost = function(self, event, target, player, data)
    return player.room:askForSkillInvoke(player, self.name, nil)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    for _, pid in ipairs(AimGroup:getAllTargets(data.tos)) do
      local p = player.room:getPlayerById(pid)
      if p:getMark("@zhuixi-turn") > 1 then
        if #p:getCardIds("hej") > 0 then
          local cid = room:askForCardChosen(player, p, "hej", self.name)
          room:obtainCard(player, cid, false, fk.ReasonPrey)
        end
        room:setPlayerMark(p, "@zhuixi-turn", 0)
      end
    end
    for _, i in ipairs(room.alive_players) do
      if i:getMark("@zhuixi-turn") ~= 0 then
        room:setPlayerMark(i, "@zhuixi-turn", 0)
      end
    end
  end,

  refresh_events = { fk.TargetSpecifying },
  can_refresh = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and data.card and data.firstTarget
  end,
  on_refresh = function(self, event, target, player, data)
    for _, id in ipairs(AimGroup:getAllTargets(data.tos)) do
      local p = player.room:getPlayerById(id)
      if p ~= player and p:getMark("@zhuixi-turn") < 2 then
        player.room:addPlayerMark(p, "@zhuixi-turn", 1)
      end
    end
  end,
}
huoqubing:addSkill(dz_zhuixi)
Fk:loadTranslationTable {
  ["dz_zhuixi"] = "追袭",
  [":dz_zhuixi"] = "当你于一个回合内对其他角色连续使用两张牌时，若两张牌的目标完全相同，你可以获得这些目标各一张牌，若为单体牌，获得目标一张牌并重新计数。",

  ["@zhuixi-turn"] = "袭",
}
local dz_guanjun = fk.CreateTriggerSkill {
  name = "dz_guanjun",
  anim_type = "offensive",
  events = { fk.EventPhaseChanging },
  can_trigger = function(self, event, target, player, data)
    return target == player and data.to == Player.NotActive and player:hasSkill(self) and
        (table.every(player.room:getOtherPlayers(player), function(p) return player.hp >= p.hp end)
          or table.every(player.room:getOtherPlayers(player), function(p)
            return player:getHandcardNum() >=
                p:getHandcardNum()
          end)
          or player:getMark("201-round") > 0)
  end,
  on_cost = Util.TrueFunc,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if table.every(player.room:getOtherPlayers(player), function(p) return player.hp >= p.hp end) then
      if room:askForSkillInvoke(player, self.name, nil, "冠军：是否摸三张牌，若因此手牌全场最高，可以使用【杀】") then
        player:drawCards(3, self.name)
      end
    end
    if table.every(player.room:getOtherPlayers(player), function(p)
          return player:getHandcardNum() >= p:getHandcardNum()
        end) then
      if room:askForSkillInvoke(player, self.name, nil, "冠军：是否一名角色使用一张【杀】") then
        local to = room:askForChoosePlayers(player, table.map(player.room.alive_players, function(p)
          return p.id ~= player.id and p.id
        end), 1, 1, "冠军：请选择要使用【杀】的目标", self.name, true)
        if #to > 0 then
          local use = {
            from = player.id,
            tos = { { to[1] } },
            card = Fk:cloneCard("slash"),
            extraUse = true,
          }
          use.card.skillName = self.name
          room:useCard(use)
        end
      end
    end
    if player:getMark("201-round") > 0 then
      if room:askForSkillInvoke(player, self.name, nil, "冠军：是否获得至多两名角色的各一张牌") then
        local to = room:askForChoosePlayers(player, table.map(player.room.alive_players, function(p)
          return #p:getCardIds { Player.Hand, Player.Equip, Player.Judge } > 0 and p.id
        end), 0, 2, "冠军：选择至多两名角色，获得其区域内的一张牌", self.name, true)
        if #to > 0 then
          for _, p in ipairs(to) do
            local z = room:getPlayerById(p)
            local id = room:askForCardChosen(player, z, "hej", self.name)
            room:obtainCard(player, id, false, fk.ReasonPrey)
          end
        end
      end
    end
  end,
}
local dz_guanjun_trigger = fk.CreateTriggerSkill {
  name = "#dz_guanjun_trigger",
  anim_type = "offensive",
  mute = true,
  events = { fk.EventPhaseEnd, fk.Damage },
  can_trigger = function(self, event, target, player, data)
    if event == fk.EventPhaseEnd then
      return target == player and player.phase == Player.Discard and player:hasSkill("dz_guanjun") and
          player:getMark("201-round") > 0
    else
      if target == player and player:hasSkill("dz_guanjun") then
        local damage_event = player.room.logic:getCurrentEvent()
        if not damage_event then return false end
        local x = player:getMark("dz_guanjun-round")
        player.room.logic:getEventsOfScope(GameEvent.ChangeHp, 1, function(e)
          local reason = e.data[3]
          if reason == "damage" then
            local first_damage_event = e:findParent(GameEvent.Damage)
            if first_damage_event then
              x = first_damage_event.id
              player.room:setPlayerMark(player, "dz_guanjun-round", x)
            end
            return true
          end
        end, Player.HistoryRound)
        return damage_event.id == x
      end
    end
  end,
  on_cost = Util.TrueFunc,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.EventPhaseEnd then
      if table.every(player.room:getOtherPlayers(player), function(p) return player.hp >= p.hp end) then
        room:setPlayerMark(player, "@@guanjun_mopai-turn", 1)
      end
      if table.every(player.room:getOtherPlayers(player), function(p)
            return player:getHandcardNum() >= p:getHandcardNum()
          end) then
        room:setPlayerMark(player, "@@guanjun_chusha-turn", 1)
      end
      if player:getMark("201-round") > 0 then
        room:setPlayerMark(player, "@@guanjun_napai-turn", 1)
      end
    else
      room:setPlayerMark(player, "201-round", 1)
    end
  end,
}
dz_guanjun:addRelatedSkill(dz_guanjun_trigger)
huoqubing:addSkill(dz_guanjun)
Fk:loadTranslationTable {
  ["dz_guanjun"] = "冠军",
  [":dz_guanjun"] = "结束阶段：<br>①若你的体力值为全场最高，你摸三张牌，若因此手牌数达到全场最高，仍可触发②；<br>②若你的手牌为全场最多，你可以视为使用一张无距离和次数限制的【杀】；<br>③若你是本轮首次造成伤害的角色，你可以获得至多两名角色区域内的各一张牌。",

  ["@@guanjun_mopai-turn"] = "冠军 摸牌",
  ["@@guanjun_chusha-turn"] = " 冠军 出杀",
  ["@@guanjun_napai-turn"] = " 冠军 拿牌",
}
return extension