=begin

 ▼ 戦闘切り替えエフェクト ver 2.1.1
 
 RPGツクールVXAce用スクリプト
 
 制作 : 木星ペンギン
 URL  : http://woodpenguin.blog.fc2.com/

------------------------------------------------------------------------------
 概要

 □ 戦闘突入時のエフェクトをオリジナルのものにします。
  ・とにかく重いので、適当に調整してください。

------------------------------------------------------------------------------
 使い方
 
 □ フェードアウトエフェクト
  マップ画面から暗転までのエフェクトです。
  -1 : 暗転なし。
  0  : 通常のトランジションを行います。
  1  : 回転しながらアップになる演出を行います。
  2  : 幻影を残しながら、画面を縮小していきます。
  3  : いったん画面を縮小してから、プレイヤーを拡大します。
  4  : 波形描写を行います。
  5  : 画面を回転させながらぼかし効果を適用します。
  6  : 波形描写を行いながら、横に引き伸ばします。
  7  : 画面を白くフラッシュさせます。
  8  : 新たに設定したトランジションを行います。
  9  : 画面が割れて飛び散っていく演出を行います。
 
 □ フェードインエフェクト
  暗転した状態から戦闘画面までのエフェクトです。
  0 : 通常のフェードインを行います。
  1 : 通常のトランジションを行います。
  2 : 新たに設定したトランジションを行います。
  3 : 波形描写を行います。
  4 : 画面が割れて飛び散っていく演出を行います。
 
=end
module WdTk
module PrBtEff
#//////////////////////////////////////////////////////////////////////////////
#
# 設定項目
#
#//////////////////////////////////////////////////////////////////////////////
=begin #---------------------------------------------------------------------

    ● エフェクト共通の設定項目の説明
      :rate    : エフェクトの更新レートです。
                 数値が大きいほどFPSは下がりますが、処理が軽くなります。
                 1 以上の数値を設定してください。
      :time    : エフェクトにかける時間を設定できます。
                 60 で 1 秒です。
      :fadeout : 最後にフェードアウトをかける時間です。
      :fadein  : 背景にフェードインをかける時間です。
      
=end #-----------------------------------------------------------------------
  OUTEFF = Array.new(10) { {} }
  INEFF  = Array.new(5) { {} }
  #--------------------------------------------------------------------------
  # ● フェードアウト設定
  #     OUT_VARIABLE : 変数を使用するかどうか
  #     OUT_INDEX    :
  #       変数を使用する場合、この番号の変数の値がエフェクトの番号になる。
  #       変数を使用しない場合、この数値がそのままエフェクトの番号になる。
  #--------------------------------------------------------------------------
  OUT_VARIABLE = false
  OUT_INDEX = 7
  
  #--------------------------------------------------------------------------
  # ● フェードアウトエフェクト 0 の設定
  #     通常のトランジションを行います。
  #--------------------------------------------------------------------------
  OUTEFF[0][:time] = 60
  
  #--------------------------------------------------------------------------
  # ● フェードアウトエフェクト 1 の設定
  #     回転しながらアップになる演出を行います。
  #--------------------------------------------------------------------------
  OUTEFF[1][:rate]    = 3
  OUTEFF[1][:time]    = 120
  OUTEFF[1][:fadeout] = 30
  
  #--------------------------------------------------------------------------
  # ● フェードアウトエフェクト 2 の設定
  #     幻影を残しながら、画面を縮小していきます。
  #     :type  : 縮小をする方向です。テンキーの位置で指定します。
  #     :blur  : ブレの強さです。
  #     :angle : 回転角度です。
  #--------------------------------------------------------------------------
  OUTEFF[2][:rate]    = 2
  OUTEFF[2][:time]    = 90
  OUTEFF[2][:type]    = 7
  OUTEFF[2][:blur]    = 16
  OUTEFF[2][:angle]   = 30
  OUTEFF[2][:fadeout] = 30
  
  #--------------------------------------------------------------------------
  # ● フェードアウトエフェクト 3 の設定
  #     いったん画面を縮小してから、プレイヤーを拡大します。
  #     :angle : 回転角度です。
  #--------------------------------------------------------------------------
  OUTEFF[3][:rate]    = 3
  OUTEFF[3][:time]    = 120
  OUTEFF[3][:angle]   = 30
  OUTEFF[3][:fadeout] = 30
  
  #--------------------------------------------------------------------------
  # ● フェードアウトエフェクト 4 の設定
  #     波形描写を行います。
  #     :amp    : 波形の振幅です。
  #     :length : 波形の周期です。
  #--------------------------------------------------------------------------
  OUTEFF[4][:rate]    = 1
  OUTEFF[4][:time]    = 120
  OUTEFF[4][:amp]     = 64
  OUTEFF[4][:length]  = 60
  OUTEFF[4][:fadeout] = 30
  
  #--------------------------------------------------------------------------
  # ● フェードアウトエフェクト 5 の設定
  #     画面を回転させながらぼかし効果を適用します。
  #--------------------------------------------------------------------------
  OUTEFF[5][:rate]    = 4
  OUTEFF[5][:time]    = 120
  OUTEFF[5][:fadeout] = 0
  
  #--------------------------------------------------------------------------
  # ● フェードアウトエフェクト 6 の設定
  #     波形描写を行いながら、横に引き伸ばします。
  #--------------------------------------------------------------------------
  OUTEFF[6][:rate]    = 1
  OUTEFF[6][:time]    = 45
  OUTEFF[6][:fadeout] = 180
  
  #--------------------------------------------------------------------------
  # ● フェードアウトエフェクト 7 の設定
  #     画面を白くフラッシュさせます。
  #--------------------------------------------------------------------------
  OUTEFF[7][:rate]    = 1
  OUTEFF[7][:time]    = 12
  OUTEFF[7][:fadeout] = 120
  
  #--------------------------------------------------------------------------
  # ● フェードアウトエフェクト 8 の設定
  #     新たに設定したトランジションを行います。
  #     :name : トランジションのファイル名です。
  #--------------------------------------------------------------------------
  OUTEFF[8][:time] = 30
  OUTEFF[8][:name] = "BattleStart"
  
  #--------------------------------------------------------------------------
  # ● フェードアウトエフェクト 9 の設定
  #     画面が割れて飛び散っていく演出を行います。
  #     :col    : 画面を横に分割する数です
  #     :row    : 画面を縦に分割する数です
  #     :wait   : エフェクト発生までのウェイトです。
  #--------------------------------------------------------------------------
  OUTEFF[9][:rate]    = 1
  OUTEFF[9][:time]    = 60
  OUTEFF[9][:fadeout] = 60
  OUTEFF[9][:col]     = 12
  OUTEFF[9][:row]     = 9
  OUTEFF[9][:wait]    = 10
  
  
  
  #--------------------------------------------------------------------------
  # ● フェードイン設定
  #     IN_VARIABLE : 変数を使用するかどうか
  #     IN_INDEX    :
  #       変数を使用する場合、この番号の変数の値がエフェクトの番号になる。
  #       変数を使用しない場合、この数値がそのままエフェクトの番号になる。
  #--------------------------------------------------------------------------
  IN_VARIABLE = false
  IN_INDEX = 4
  
  #--------------------------------------------------------------------------
  # ● フェードインエフェクト 0 の設定
  #     通常のフェードインを行います。
  #--------------------------------------------------------------------------
  INEFF[0][:time] = 10
  
  #--------------------------------------------------------------------------
  # ● フェードインエフェクト 1 の設定
  #     通常のトランジションを行います。
  #--------------------------------------------------------------------------
  INEFF[1][:time] = 15
  
  #--------------------------------------------------------------------------
  # ● フェードインエフェクト 2 の設定
  #     新たに設定したトランジションを行います。
  #--------------------------------------------------------------------------
  INEFF[2][:time] = 15
  INEFF[2][:name] = "BattleStart"
  
  #--------------------------------------------------------------------------
  # ● フェードインエフェクト 3 の設定
  #     波形描写を行います。
  #     :amp    : 波形の振幅です。
  #     :length : 波形の周期です。
  #--------------------------------------------------------------------------
  INEFF[3][:rate]   = 1
  INEFF[3][:time]   = 60
  INEFF[3][:fadein] = 0
  INEFF[3][:length] = 60
  INEFF[3][:amp]    = 64
  
  #--------------------------------------------------------------------------
  # ● フェードインエフェクト 4 の設定
  #     画面が割れて飛び散っていく演出を行います。
  #     :col    : 画面を横に分割する数です。
  #     :row    : 画面を縦に分割する数です。
  #     :wait   : エフェクト発生までのウェイトです。
  #--------------------------------------------------------------------------
  INEFF[4][:rate]   = 1
  INEFF[4][:time]   = 50
  INEFF[4][:fadein] = 120
  INEFF[4][:col]    = 12
  INEFF[4][:row]    = 9
  INEFF[4][:wait]   = 0
  
  
#//////////////////////////////////////////////////////////////////////////////
#
# 以降、変更する必要なし
#
#//////////////////////////////////////////////////////////////////////////////

  def self.snapshot_for_effect
    @effect_bitmap = Graphics.snap_to_bitmap
  end
  def self.dispose_effect_bitmap
    @effect_bitmap.dispose
  end
  #--------------------------------------------------------------------------
  # ● ビューポートの作成
  #--------------------------------------------------------------------------
  def self.create_main_viewport
    @viewport = Viewport.new
    @viewport.z = 500
  end
  #--------------------------------------------------------------------------
  # ● ビューポートの解放
  #--------------------------------------------------------------------------
  def self.dispose_main_viewport
    @viewport.dispose
    @viewport = nil
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新（フェードアウト用）
  #--------------------------------------------------------------------------
  def self.update_fadeout(i, d)
    Graphics.update
    @viewport.color.alpha = 255 - 255 * (180 - i) / d if d > 0
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新（フェードイン用）
  #--------------------------------------------------------------------------
  def self.update_fadein(i, d)
    @viewport2.color.alpha = 255 * (180 - i) / d if d > 0
    Graphics.update
  end
  #--------------------------------------------------------------------------
  # ● フェードアウト実行
  #--------------------------------------------------------------------------
  def self.perform_fadeout
    index = OUT_VARIABLE ? $game_variables[OUT_INDEX] : OUT_INDEX
    eff_data = OUTEFF[index]
    return if index < 0 || eff_data.nil?
    case index
    when 0
      d = eff_data[:time]
      Graphics.transition(d, "Graphics/System/BattleStart", 100)
      Graphics.freeze
      snapshot_for_effect
      return
    when 8
      d = eff_data[:time]
      name = "Graphics/System/" << eff_data[:name]
      Graphics.transition(d, name, 100)
      Graphics.freeze
      snapshot_for_effect
      return
    end
    create_main_viewport
    effect_sprites = []
    Graphics.transition(0)
    Graphics.frame_rate = 60 / eff_data[:rate]
    step = eff_data[:rate] * 180.0 / eff_data[:time]
    case index
    when 1
      opacity = eff_data[:rate] * 8 + 8
      0.step(180, step) do |i|
        sprite = make_effect_sprite1
        sprite.angle = 2 * i
        sprite.opacity = (i == 0 ? 255 : opacity)
        update_effect_size(sprite, 1.0 + 0.01 * i)
        effect_sprites << sprite
        update_fadeout(i, eff_data[:fadeout])
      end
    when 2
      type = eff_data[:type] - 1
      tx = Graphics.width  * (type % 3 == 0 ? 1 : type % 3 == 2 ? 5 : 3) / 6
      ty = Graphics.height * (type / 3 == 0 ? 5 : type / 3 == 2 ? 1 : 3) / 6
      opacity = eff_data[:rate] * 8 + 16
      0.step(180, step) do |i|
        if effect_sprites.size > eff_data[:blur]
          sprite = effect_sprites.shift
        else
          sprite = make_effect_sprite1
        end
        sprite.x = Graphics.width / 2 - (Graphics.width / 2 - tx) * i / 180
        sprite.y = Graphics.height / 2 - (Graphics.height / 2 - ty) * i / 180
        sprite.z = i
        sprite.angle = eff_data[:angle] * i / 180
        d = (i > 90 ? (180 - i) : 90)
        sprite.opacity = (255 - i) * d / 90
        effect_sprites.last.opacity = opacity * d / 90 unless effect_sprites.empty?
        update_effect_size(sprite, 0.2 + 0.8 * (180 - i) ** 2 / 180 ** 2)
        effect_sprites << sprite
        update_fadeout(i, eff_data[:fadeout])
      end
    when 3
      tx = $game_player.screen_x
      ty = $game_player.screen_y - 20
      opacity = eff_data[:rate] * 8 + 8
      0.step(180, step) do |i|
        sprite = make_effect_sprite1
        sprite.x = tx + (Graphics.width / 2 - tx) * i / 180
        sprite.y = ty + (Graphics.height / 2 - ty) * i / 180
        sprite.z = i
        sprite.ox = tx
        sprite.oy = ty
        sprite.angle = eff_data[:angle] * i / 180
        sprite.opacity = (i == 0 ? 255 : opacity)
        m = 60 ** 2 - 30 ** 2 + (30 - i) ** 2
        update_effect_size(sprite, 1.0 * m / 60 ** 2, 0.75)
        effect_sprites << sprite
        update_fadeout(i, eff_data[:fadeout])
      end
    when 4
      effect_sprites << make_effect_sprite1
      effect_sprites << make_effect_sprite1
      effect_sprites[1].opacity = 64
      effect_sprites[1].wave_length = eff_data[:length]
      0.step(180, step) do |i|
        m = 180 ** 2
        d = m - (180 - i) ** 2
        effect_sprites[1].wave_amp = eff_data[:amp] * d / m
        effect_sprites[1].wave_speed = i * 4
        effect_sprites[1].opacity += 1
        effect_sprites[1].update
        update_fadeout(i, eff_data[:fadeout])
      end
    when 5
      effect_sprites << make_effect_sprite1
      0.step(180, step) do |i|
        @effect_bitmap.radial_blur(i / 3, 1)
        update_fadeout(i, eff_data[:fadeout])
      end
    when 6
      @viewport.color.set(255, 255, 255, 0)
      17.times do |i|
        sprite = make_effect_sprite1
        sprite.z = 17 - i
        x = (16 - i) * 16
        w = (i + 1) * 32
        sprite.ox = w / 2
        sprite.src_rect.set(x, 0, w, Graphics.height)
        effect_sprites << sprite
      end
      0.step(180, step) do |i|
        effect_sprites.each_with_index do |sprite, n|
          sprite.wave_length = 96
          sprite.wave_amp = i * n / 17 * 3 / 2
          sprite.zoom_x = 1 + 1.0 * i / 180 * n / 17
        end
        update_fadeout(i, eff_data[:fadeout])
      end
    when 7
      @viewport.color.set(255, 255, 255, 0)
      effect_sprites << make_effect_sprite1
      0.step(180, step) do |i|
        sprite = make_effect_sprite1
        sprite.opacity = 32
        sprite.zoom_x = sprite.zoom_y = 1.0 + 2.0 * i / 180
        effect_sprites << sprite
        update_fadeout(i, eff_data[:fadeout])
      end
    when 9
      effect_sprites = make_break_sprites(eff_data[:col], eff_data[:row])
      Graphics.wait(eff_data[:wait])
      effect_data = effect_sprites.collect {|sprite| make_effect_data(sprite) }
      0.step(180, step) do |i|
        if i < 90
          d = (45 ** 2 - (i - 45) ** 2) / 40
        else
          d = (90 - i) * 2
        end
        d = d * eff_data[:time] / 180.0
        effect_sprites.each_with_index do |sprite, n|
          data = effect_data[n]
          m = i - data[0]
          next if m <= 0
          zoom = data[1] - (data[1] - 1) * (179 - m) ** 2 / 180 ** 2
          next sprite.visible = false if zoom > 6
          sprite.x = data[2] + data[3] * (179 - m) ** 2 / 180 ** 2
          sprite.y = data[4] + data[5] * (179 - m) ** 2 / 180 ** 2
          sprite.y -= d * zoom if data[1] < 16
          sprite.z = data[1] * 100
          zoom_x = zoom * Math.cos(m * data[7] * Math::PI / 360)
          zoom_y = zoom * Math.cos(m * data[8] * Math::PI / 360)
          sprite.mirror = (zoom_x < 0) != (zoom_y < 0)
          sprite.ox = sprite.mirror ? sprite.width - data[9] : data[9]
          sprite.zoom_x = zoom_x.abs
          sprite.zoom_y = zoom_y.abs
          sprite.angle = m * data[6] / 2 + (zoom_y < 0 ? 180 : 0)
        end
        update_fadeout(i, eff_data[:fadeout])
      end
    end
    snapshot_for_effect
    Graphics.freeze
    Graphics.frame_rate = 60
    dispose_main_viewport
    effect_sprites.each {|sprite| sprite.dispose }
  end
  #--------------------------------------------------------------------------
  # ● フェードイン実行
  #--------------------------------------------------------------------------
  def self.perform_fadein
    index = IN_VARIABLE ? $game_variables[IN_INDEX] : IN_INDEX
    eff_data = INEFF[index]
    case index
    when 0
      Graphics.transition(eff_data[:time])
      return
    when 1
      d = eff_data[:time]
      Graphics.transition(d,"Graphics/System/BattleStart", 100)
      return
    when 2
      d = eff_data[:time]
      name = "Graphics/System/" << eff_data[:name]
      Graphics.transition(d, name, 100)
      return
    end
    create_main_viewport
    @viewport2 = Viewport.new
    @viewport2.z = 450
    Graphics.transition(0)
    effect_sprites = []
    effect_sprites << make_back_sprite(@viewport2)
    step = eff_data[:rate] * 180.0 / eff_data[:time]
    case index
    when 3
      effect_sprites[0].wave_length = eff_data[:length]
      effect_sprites << make_effect_sprite1
      effect_sprites[1].z += 1
      0.step(180, step) do |i|
        m = 180 ** 2
        d = m - i ** 2
        effect_sprites[0].wave_amp = eff_data[:amp] * d / m
        effect_sprites[0].wave_speed = (180 - i) * 4
        effect_sprites[0].opacity = (180 - i) * 3 / 2
        effect_sprites[0].update
        effect_sprites[1].opacity = 255 - 255 * i / 60
        update_fadein(i, eff_data[:fadein])
      end
    when 4
      effect_sprites.concat(make_break_sprites(eff_data[:col], eff_data[:row]))
      Graphics.wait(eff_data[:wait])
      effect_data = effect_sprites.collect {|sprite| make_effect_data(sprite) }
      0.step(180, step) do |i|
        if i < 90
          d = (45 ** 2 - (i - 45) ** 2) / 40
        else
          d = (90 - i) * 2
        end
        d = d * eff_data[:time] / 180.0
        effect_sprites.each_with_index do |sprite, n|
          data = effect_data[n]
          m = i - data[0]
          next if m <= 0
          zoom = data[1] - (data[1] - 1) * (179 - m) ** 2 / 180 ** 2
          next sprite.visible = false if zoom > 6
          sprite.x = data[2] + data[3] * (179 - m) ** 2 / 180 ** 2
          sprite.y = data[4] + data[5] * (179 - m) ** 2 / 180 ** 2
          sprite.y -= d * zoom if data[1] < 16
          sprite.z = data[1] * 100
          zoom_x = zoom * Math.cos(m * data[7] * Math::PI / 180)
          zoom_y = zoom * Math.cos(m * data[8] * Math::PI / 180)
          sprite.mirror = (zoom_x < 0) != (zoom_y < 0)
          sprite.ox = sprite.mirror ? sprite.width - data[9] : data[9]
          sprite.zoom_x = zoom_x.abs
          sprite.zoom_y = zoom_y.abs
          sprite.angle = m * data[6] + (zoom_y < 0 ? 180 : 0)
          sprite.opacity = (180 - i) * 3
        end
        update_fadein(i, eff_data[:fadein])
      end
    end
    dispose_main_viewport
    @viewport2.dispose
    dispose_effect_bitmap
    effect_sprites.each {|sprite| sprite.dispose }
  end
  #--------------------------------------------------------------------------
  # ● エフェクトスプライトの作成 1
  #--------------------------------------------------------------------------
  def self.make_effect_sprite1
    sprite = Sprite.new(@viewport)
    sprite.bitmap = @effect_bitmap
    sprite.x = sprite.ox = Graphics.width / 2
    sprite.y = sprite.oy = Graphics.height / 2
    sprite
  end
  #--------------------------------------------------------------------------
  # ● エフェクトの大きさ設定
  #--------------------------------------------------------------------------
  def self.update_effect_size(sprite, zoom, rate = 1.1)
    sprite.zoom_x = sprite.zoom_y = zoom
    if zoom > 1
      w =  (@effect_bitmap.width / zoom / rate).to_i / 2
      h =  (@effect_bitmap.height / zoom / rate).to_i / 2
      cx = [sprite.ox - w, 0].max
      cy = [sprite.oy - h, 0].max
      cw = [sprite.ox + w, @effect_bitmap.width].min - cx
      ch = [sprite.oy + h, @effect_bitmap.height].min - cy
      sprite.ox += sprite.src_rect.x - cx
      sprite.oy += sprite.src_rect.y - cy
      sprite.src_rect.set(cx, cy, cw, ch)
      Graphics.frame_reset
    end
  end
  #--------------------------------------------------------------------------
  # ● 画面破壊用エフェクト準備
  #--------------------------------------------------------------------------
  def self.make_break_sprites(col, row)
    sprites = []
    rect = Rect.new
    col.times do |x| row.times do |y|
      rect.x = Graphics.width * x / col
      rect.y = Graphics.height * y / row
      rect.width = Graphics.width * (x + 1) / col - rect.x
      rect.height = Graphics.height * (y + 1) / row - rect.y
      sprites << make_effect_sprite2(rect, 0)
      sprites << make_effect_sprite2(rect, 2)
    end; end
    Graphics.frame_reset
    sprites
  end
  #--------------------------------------------------------------------------
  # ● エフェクトスプライトの作成 2
  #--------------------------------------------------------------------------
  def self.make_effect_sprite2(rect, pos)
    sprite = Sprite.new(@viewport)
    sprite.bitmap = Bitmap.new(rect.width, rect.height)
    sprite.bitmap.blt(0, 0, @effect_bitmap, rect)
    d = [rect.width, rect.height].max
    if pos == 0
      d.times {|i| sprite.bitmap.clear_rect(rect.width * (d - i) / d, i, i, 1) }
    else
      d.times {|i| sprite.bitmap.clear_rect(0, i, rect.width * (d - i) / d, 1) }
    end
    sprite.ox = rect.width * (pos + 1) / 4
    sprite.oy = rect.height * (pos + 1) / 4
    sprite.x = rect.x + sprite.ox
    sprite.y = rect.y + sprite.oy
    sprite
  end
  #--------------------------------------------------------------------------
  # ● 背景スプライトの作成
  #--------------------------------------------------------------------------
  def self.make_back_sprite(viewport)
    sprite = Sprite.new(viewport)
    sprite.bitmap = Graphics.snap_to_bitmap
    sprite
  end
  #--------------------------------------------------------------------------
  # ● エフェクトデータの作成
  #--------------------------------------------------------------------------
  def self.make_effect_data(sprite)
    sx = sprite.x - Graphics.width / 2
    sy = sprite.y - Graphics.height / 2
    zoom = Math.asin(1 - Math.hypot(sx, sy) / 360) * rand(6) ** 2 / 10 + 1
    rate = 3.5
    zoom = rate = 20.0 if zoom > 2.5 && rand(3) == 0
    tx = (sx - rand(17) + 8) * rate + Graphics.width / 2
    ty = (sy - rand(13) + 6) * rate + Graphics.height / 2# + 64
    angle = (rand(32) + 1) * (rand(2) == 0 ? 1 : -1) / 4.0
    ax = (rand(32) + 1) * (rand(2) == 0 ? 1 : -1) / 4.0
    ay = rand(33) * (rand(2) == 0 ? 1 : -1) / 4.0
    [rand(3), zoom, tx, sprite.x - tx, ty, sprite.y - ty, angle, ax, ay, sprite.ox]
  end
  
end

  @material ||= []
  @material << :PrBtEff
  def self.include?(sym)
    @material.include?(sym)
  end

end

#==============================================================================
# ■ Scene_Map
#==============================================================================
class Scene_Map
  #--------------------------------------------------------------------------
  # ◯ 終了前処理
  #--------------------------------------------------------------------------
  alias _wooden_prebteff_pre_terminate pre_terminate
  def pre_terminate
    WdTk::PrBtEff.snapshot_for_effect if SceneManager.scene_is?(Scene_Battle)
    _wooden_prebteff_pre_terminate
  end
  #--------------------------------------------------------------------------
  # ☆ 戦闘前トランジション実行
  #--------------------------------------------------------------------------
  def perform_battle_transition
    WdTk::PrBtEff.perform_fadeout
  end
end

#==============================================================================
# ■ Scene_Battle
#==============================================================================
class Scene_Battle
  #--------------------------------------------------------------------------
  # ☆ トランジション実行
  #--------------------------------------------------------------------------
  def perform_transition
    return if $BTEST
    WdTk::PrBtEff.perform_fadein
    WdTk::PrBtEff.dispose_effect_bitmap
  end
end