#==============================================================================
# ■ VX-RGSS2-3 閃きシステム [Ver.1.2.0]   by Claimh
#==============================================================================

module SysFlash
  module_function
  #------------------------------------------------------------------------
  # ● 併用化処理
  # 連続攻撃系＋閃き無効化処理系のスクリプトと併用時の無効化処理を包含する
  #------------------------------------------------------------------------
  def can_flash?(battler)
    #スイッチで抑制する例
    # return false if $game_switches[id]
    #※仕様※ 連続攻撃系スクリプトと併用する場合、連続攻撃中は閃かない
=begin  !!機能制限により使用不可!!
    # 追尾攻撃との併用時
    if defined?(ExtraAttack)
      return false if $scene.add_atk_exercise
    end
    # スキル連撃との併用時
    if defined?(ExtraSkill)
      return false if $scene.skill_chase_exercise
    end
    # 一人連携との併用時
    if defined?(SkillLink)
      return false if $scene.skill_linked
    end
=end
    # 閃き動作中は不可
    return false if battler.flash_flg
    # 閃き可能
    return true
  end
  #------------------------------------------------------------------------
  # ● スキル派生可能？
  #------------------------------------------------------------------------
  def can_derive?(skill_id)
    return false unless DERIVE_FLASH
    return false if NOT_FLASH_SKILL.include?(skill_id)
    return true
  end
  #------------------------------------------------------------------------
  # ● スキルからの通常閃き可能？
  #------------------------------------------------------------------------
  def can_skill_normal?(skill_id)
    return false unless SKILL_NORMAL_FLASH
    return false if NOT_FLASH_SKILL.include?(skill_id)
    return false if ONLY_DERIVE_SKILL.include?(skill_id)
    return true
  end
  #------------------------------------------------------------------------
  # ● 設定情報をクラス化   熟練度による閃き制限
  #------------------------------------------------------------------------
  class AttrFlash
    attr_reader:condition  # 条件
    def initialize(actor, data)
      @actor = actor
      @condition = []
      for d in data
        @condition.push(AttrFlashCondition.new(d))
      end
    end
    # 熟練度制限の判定
    def judgement
      for c in @condition
        # アクターの熟練度が足りてない
        if actor.attr[c.attr_id].level < c.level
          return false
        end
      end
      return true
    end
    class AttrFlashCondition
      attr_reader:attr_id  # 属性ID
      attr_reader:level    # 必要Lv
      def initialize(data)
        @attr_id = data[0]
        @level   = data[1]
      end
    end
  end
  #------------------------------------------------------------------------
  # ● 設定情報をクラス化   熟練度による閃き制限
  #------------------------------------------------------------------------
  def get_skill_lv_limitter(skill_id)
    return 0 if SKILL_LV_LIMIT[skill_id].nil?
    return SKILL_LV_LIMIT[skill_id]
  end
################################################################################
  #--------------------------------------------------------------------------
  # ● 通常攻撃時の閃き判定(前処理)
  #--------------------------------------------------------------------------
  def normal_flash(battler)
    return unless can_flash?(battler)
    # 通常閃き
    if NORMAL_FLASH and battler.is_a?(Game_Actor)
      SysFlash.sys_flash_main(TYPE_NORMAL, battler)
    end
    # エネミー閃き
    if ENEMY_NORMAL and battler.is_a?(Game_Enemy)
      SysFlash.sys_flash_main(TYPE_ENEMY, battler)
    end
  end
  #--------------------------------------------------------------------------
  # ● スキル使用時の閃き判定(前処理)
  #--------------------------------------------------------------------------
  def skill_flash(battler)
    # スキルを取得
    skill_id = battler.action.skill_id
    # 既に閃き状態のときや閃き対象外のスキル使用時は判定しない
    if can_flash?(battler)
      # アクター
      if battler.is_a?(Game_Actor)
        if can_derive?(skill_id)
          # 使用回数カウント(使用回数を使用する場合のみ)
          battler.skill_count(skill_id) if DEREIVE_USE
          # 派生閃きメイン処理へ
          sys_flash_main(TYPE_DERIVE, battler)
          if battler.flash_flg   # 閃き成功
            # スキルから閃いた場合、スキル使用回数のカウントはしない
            battler.skill_recount(skill_id) if DEREIVE_USE
          # スキル使用時通常閃き：スキル派生閃き失敗時に適応される
          elsif can_skill_normal?(skill_id)
            sys_flash_main(TYPE_NORMAL, battler)
            if battler.flash_flg   # 閃き成功
              # スキルから閃いた場合、スキル使用回数のカウントはしない
              battler.skill_recount(skill_id) if DEREIVE_USE
            end
          end
        # スキル使用時通常閃き：スキル派生しない場合はここで。
        elsif can_skill_normal?(skill_id)
          sys_flash_main(TYPE_NORMAL, battler)
        end
      # エネミー閃き
      elsif ENEMY_SKILL and battler.is_a?(Game_Enemy)
        sys_flash_main(TYPE_ENEMY, battler)
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● 閃きシステム メイン処理
  #--------------------------------------------------------------------------
  def sys_flash_main(type, battler)
    # 閃き対象のスキル群を取得
    case type
    when TYPE_NORMAL;  f_skill = divide_normal(battler)
    when TYPE_DERIVE;  f_skill = divide_derive(battler, battler.action.skill_id)
    when TYPE_ENEMY;   f_skill = divide_enemy(battler)
    else; return
    end
    return if f_skill.nil? or !f_skill.can_flash # 対象なし
    battler.flash_flg = true # 閃き有効
    # 閃き判定
    if battler.is_a?(Game_Actor)
      battler.learn_skill(f_skill.skill_id)  # 一旦、習得させる
      unless jugde_flash_actor(type, battler, f_skill)
        battler.forget_skill(f_skill.skill_id) # スキル忘却
        battler.flash_flg = false # 閃き無効
        return
      end
    else
      # 既に閃き済みでもスキル行動ならそのまま発動させる
      if battler.skill_learn?($data_skills[f_skill.skill_id]) and battler.action.kind == 1
        battler.action.skill_id = f_skill.skill_id
        battler.flash_flg = false # 閃き無効
        return
      end
      unless jugde_flash_enemy(battler, f_skill)
        battler.flash_flg = false # 閃き無効
        return
      end
      battler.learn_skill(f_skill.skill_id)  # 習得させる
    end
    # 発動スキル変更
    battler.action.skill_id = f_skill.skill_id
    # ターゲットを作り直す
    battler.action.make_targets
  end
  #--------------------------------------------------------------------------
  # ● 閃き判定 ：通常閃き & スキル派生 共通処理
  #--------------------------------------------------------------------------
  def jugde_flash_actor(type, actor, flash)
    # スキルを使用できるか？
    return false unless actor.skill_can_use?($data_skills[flash.skill_id])
    # スキル派生：習得条件に適合しているか？
    return false if type == TYPE_DERIVE and (flash.judgement == false)

    skill_id = actor.action.skill_id
    if defined?(SysUpdate)  # 熟練度システムがある場合のみ
      # 熟練度による閃き制限を使用する
      if USE_ATTR_LV_LIMER and !ATTR_LIMIT_SKILL[flash.skill_id].nil?
        limitter = AttrFlash.new(ATTR_LIMIT_SKILL[flash.skill_id])
        # 熟練度Lv未到達のため閃かない
        return false unless limitter.judgement
      end
      # 攻撃属性が得意・不得意かによって確率を変動させる
      if USE_ATK_ATTR_UP
        case type
        when TYPE_DERIVE; attr_id = SysUpdate.skill_attr(actor, skill_id).id
        when TYPE_NORMAL; attr_id = SysUpdate.atk_attr(actor).id
        end
        case actor.attr[attr_id].taste
        when SysUpdate::ATTR_GOOD; flash.prob += ATTR_PRO_UP
        when SysUpdate::ATTR_BAD;  flash.prob -= ATTR_PRO_UP
        end
      end
      # 閃き対象の攻撃属性が得意・不得意かによって確率を変動させる
      if USE_FLASH_ATTR_UP
        case actor.attr[SysUpdate.skill_attr(actor, flash.skill_id).id].taste
        when SysUpdate::ATTR_GOOD; flash.prob += ATTR_PRO_UP
        when SysUpdate::ATTR_BAD;  flash.prob -= ATTR_PRO_UP
        end
      end
    end
=begin  !!機能制限により使用不可!!
    if type == TYPE_DERIVE and defined?(SkillUpdate)  # スキルアップデートがある場合のみ
      # スキルレベルによる閃き制限
      if USE_SKILL_LV_LIMER
        limitter = get_skill_lv_limitter(skill_id)
        return false if actor.skill[skill_id].level < limitter
      end
      # スキルレベルによる閃き率上昇
      if USE_SKILL_LV_UP and type == TYPE_DERIVE
        flash.prob += actor.skill[skill_id].level * SKILL_LV_PRO_UP
      end
    end
=end
    # 強い敵と遭遇したときは閃き率上昇
    if USE_DIF_LV_UP and defined?(EnemyLevel)
      enemy_lv = 0
      for enemy in $game_troop.enemies
        enemy_lv = enemy.level if enemy_lv < enemy.level
      end
      # 設定したレベル差以上あれば確率UP
      if (enemy_lv - actor.level) >= DIF_LEVEL
        flash.prob += ENEMY_LEVEL_PRO_UP
      end
    end
    # ピンチのときは閃き率上昇
    if USE_PINCH_UP and actor.hp < (actor.maxhp * PINCH_HP_RATE / 100).truncate
      flash.prob += PINCH_PRO_UP
    end

    # 最終判定
    return flash.exe_prob
  end
#----------------------------------------------------------------------------
# ■ 通常閃き
#----------------------------------------------------------------------------
  #------------------------------------------------------------------------
  # ● 設定情報をクラス化   通常閃き & エネミー閃き 共通処理
  #------------------------------------------------------------------------
  class NormalFlash
    def initialize(battler, data)
      @battler = battler
      @set = []
      for d in data
        # 対象に入れるかを先読みしてから入れる
        @set.push(NormalFlashData.new(d)) if can_include?(d[0])
      end
    end
    def can_include?(skill_id)  # 閃き対象に入れるか？
      if @battler.is_a?(Game_Actor) and @battler.skill_learn?($data_skills[skill_id])
        return false  # アクターなら習得済みは入れない
      end
      if @battler.action.kind == 1 # スキル使用時の通常閃き
        use_skill   = $data_skills[@battler.action.skill_id]
        flash_skill = $data_skills[skill_id]
        # 威力の落ちるスキルは対象にしない
        return false if DISABLE_PW_DOWN and use_skill.base_damage.abs > flash_skill.base_damage.abs
        if ONLY_SAME_ELEMENT # 同一属性のスキル以外は対象にしない
          use_elements   = use_skill.element_set.dup
          flash_elements = flash_skill.element_set.dup
          for element in UNCHECK_ELEMENTS
            use_elements.delete(element)
            flash_elements.delete(element)
          end
          element_ok = use_elements.empty?
          for element in flash_elements
            if use_elements.include?(element)
              element_ok = true
              break
            end
          end
          return false unless element_ok
        end
      end
      return true
    end
    def randum_set    # ランダム抽出
      return @set[rand(@set.size)]
    end
    class NormalFlashData
      attr_reader  :skill_id  # スキルID
      attr_accessor:prob      # 確率
      def initialize(data)
        @skill_id = data[0]
        @prob     = data[1]
      end
      def can_flash
        return true
      end
      def exe_prob      # 確率OK?
        return rand(10000)/100.0 < @prob ? true : false
      end
      # 条件適合判定
      def judgement
        return true
      end
    end
  end
#----------------------------------------------------------------------------
# ■ Flash System　スキル派生版
#----------------------------------------------------------------------------
  #------------------------------------------------------------------------
  # ● 設定情報をクラス化   スキル派生
  #------------------------------------------------------------------------
  class DeriveFlash
    attr_accessor:prob      # 確率
    attr_reader  :condition # 閃き条件
    attr_reader  :skill_id  # スキルID
    attr_reader  :can_flash # 閃き可能？
    def initialize(actor, data, skill_id)
      @actor = actor
      @use_skill_id = skill_id
      @can_flash = false
      set_data = []
      # 派生は先にランダム決定する
      for d in data
        set_data.push(d) if can_include?(d[2])
      end
      rand_set = set_data[rand(set_data.size)]
      # 
      return if rand_set.nil? # 習得スキルなしなら終わり
      @can_flash = true
      @prob = rand_set[0]
      @condition = rand_set[1]
      @skill_id = rand_set[2]
    end
    def can_include?(skill_id)  # 閃き対象に入れるか？
      return false if @actor.skill_learn?($data_skills[skill_id]) # 習得済みは含めない
      return true
    end
    # 条件適合判定
    def judgement
      return false unless @can_flash
      return true if @condition.nil? # 条件なし
      for skill in @condition
        return false unless @actor.skill_learn?($data_skills[skill])
      end
      return true
    end
    def exe_prob      # 確率OK?
      return false unless @can_flash
      if DEREIVE_USE
        return @actor.skill_use[@use_skill_id] < @prob ? true : false
      else
        return rand(10000)/100.0 < @prob ? true : false
      end
    end
  end
#----------------------------------------------------------------------------
# ■ エネミー閃き
#----------------------------------------------------------------------------
  #--------------------------------------------------------------------------
  # ● エネミー 対象振り分け
  #--------------------------------------------------------------------------
  def divide_enemy(enemy)
    flash_skills = E_FLASH[enemy.id]
    # 空定義は無視する。
    return nil if flash_skills.nil? or flash_skills.empty?
    # 閃き対象がある場合はクラス化して返す
    return NormalFlash.new(enemy, flash_skills.dup).randum_set
  end
  #--------------------------------------------------------------------------
  # ● エネミー閃き　メイン処理
  #--------------------------------------------------------------------------
  def jugde_flash_enemy(enemy, flash)
    # スキルを使用できるか？
    return false unless enemy.skill_can_use?($data_skills[flash.skill_id])
    # 最終判定
    return flash.exe_prob
  end
end


#==============================================================================
# ■ Game_Battler
#==============================================================================
class Game_Battler
  attr_accessor   :flash_flg      # 閃きフラグ
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  alias sys_flash_initialize initialize
  def initialize
    sys_flash_initialize
    @flash_flg = false
  end
  #--------------------------------------------------------------------------
  # ● スキルの消費 MP 計算
  #     skill : スキル
  #--------------------------------------------------------------------------
  alias calc_mp_cost_sysflash calc_mp_cost
  def calc_mp_cost(skill)
    if defined?(SysFlash) and SysFlash::FLASH_COST and self.flash_flg
      return 0
    else
      return calc_mp_cost_sysflash(skill)
    end
  end
end

#==============================================================================
# ■ Game_Actor
#==============================================================================
# スキル使用回数を使用する場合のみ有効。スキル派生なしなら不要パラメータ
if SysFlash::DEREIVE_USE and SysFlash::DERIVE_FLASH
class Game_Actor < Game_Battler
  attr_accessor   :skill_use      # スキル使用回数
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  alias sys_flash_init initialize
  def initialize(actor_id)
    sys_flash_init(actor_id)
    @skill_use = []
  end
  #--------------------------------------------------------------------------
  # ● スキル使用回数カウント
  #--------------------------------------------------------------------------
  def skill_count(skill_id)
    @skill_use[skill_id] = @skill_use[skill_id].nil? ? 1 : @skill_use[skill_id] + 1
  end
  #--------------------------------------------------------------------------
  # ● スキル使用回数カウント補正
  #--------------------------------------------------------------------------
  def skill_recount(skill_id)
    @skill_use[skill_id] = @skill_use[skill_id].nil? ? 0 :
                  (@skill_use[skill_id] == 0 ? 0 : @skill_use[skill_id] - 1)
  end
end
end # SysFlash::DEREIVE_USE and SysFlash::DERIVE_FLASH

#==============================================================================
# ■ Game_Enemy
#==============================================================================
class Game_Enemy < Game_Battler
  attr_reader   :skills                   # スキル
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  alias sys_flash_init initialize
  def initialize(index, enemy_id)
    sys_flash_init(index, enemy_id)
    @skills = []
    for action in $data_enemies[enemy_id].actions
      @skills.push(action.skill_id) if action.kind == 1
    end
  end
  #--------------------------------------------------------------------------
  # ● スキルを覚える
  #--------------------------------------------------------------------------
  def learn_skill(skill_id)
    unless skill_learn?($data_skills[skill_id])
      @skills.push(skill_id)
      @skills.sort!
    end
  end
  #--------------------------------------------------------------------------
  # ● スキルの習得済み判定
  #--------------------------------------------------------------------------
  def skill_learn?(skill_id)
    return @skills.include?(skill_id)
  end
end


#----------------------------------------------------------------------------
# ■ Flash System　通常攻撃版
#----------------------------------------------------------------------------
class Scene_Battle
  #--------------------------------------------------------------------------
  # ● 戦闘行動の実行
  #--------------------------------------------------------------------------
  alias execute_action_sysflash execute_action
  def execute_action
    @active_battler.flash_flg = false   # 閃き発動フラグ
    @flash_skill_text = false
    execute_action_sysflash
    @active_battler.flash_flg = false   # 行動が終わったらフラグを戻す
  end
  #--------------------------------------------------------------------------
  # ● 戦闘行動の実行 : 攻撃
  #--------------------------------------------------------------------------
  alias execute_action_attack_flash execute_action_attack
  def execute_action_attack
    SysFlash.normal_flash(@active_battler)
    # 閃き成功時
    if @active_battler.flash_flg
      # 行動をスキルに変更
      @active_battler.action.kind = 1
      #Audio.se_play("Audio/SE/Up")
      text = sprintf("%sは%sを閃いた！", @active_battler.name, @active_battler.action.skill.name)
      @message_window.add_instant_text(text)
=begin  !!機能制限により使用不可!!
      if SysFlash::FLASH_ANIME
        display_normal_animation([@active_battler], SysFlash::FLASH_ANIMATION_ID)
        wait(SysFlash::FLASH_ANIME_WAIT)
      end
=end
      execute_action_skill    # スキル処理を実行
      return  # 通常攻撃は実行しない
    end
    execute_action_attack_flash        # 原物
  end
#----------------------------------------------------------------------------
# ■ Flash System　スキル派生版
#----------------------------------------------------------------------------
  #--------------------------------------------------------------------------
  # ● 戦闘行動の実行 : スキル
  #--------------------------------------------------------------------------
  alias execute_action_skill_flash execute_action_skill
  def execute_action_skill
    unless @active_battler.flash_flg
      SysFlash.skill_flash(@active_battler)
      if @active_battler.flash_flg
        #Audio.se_play("Audio/SE/Up")
        text = sprintf("%sは%sを閃いた！！", @active_battler.name, @active_battler.action.skill.name)
        @message_window.add_instant_text(text)
=begin  !!機能制限により使用不可!!
        if SysFlash::FLASH_ANIME
          display_normal_animation([@active_battler], SysFlash::FLASH_ANIMATION_ID)
          wait(SysFlash::FLASH_ANIME_WAIT)
        end
=end
      end
    end
    execute_action_skill_flash      # 原物
  end
end