BCJT 发表于 2018-5-10 07:07
你用的敌人默认的死亡状态，应该改第一个文本(SV有三个文本吧，你发的是第三个，这个没有特殊要求不用改)动 ...

谢谢，我又按照你说的方向找了找问题，发现可能是另一个原因引起的。
我发现影子的出现，每次都是敌人2号发动了一个背景变暗且队友透明的技能，当背景恢复后影子就出现了。。。
我怀疑是不是敌人2号技能里的“队友透明解除”搞的鬼？技能如下↓
"雷斩"          => ["山雷发动","山雷发动动画","背景变暗队友透明","透明化WT","40","山雷出击动画","山雷爆炸动画","120","伤害","透明化解除WT","座標リセット","背暗队透除" ],
如果是的话怎么才能避免呢？

你用的敌人默认的死亡状态，应该改第一个文本(SV有三个文本吧，你发的是第三个，这个没有特殊要求不用改)动作设定的内容；或者你看看是不是设置了一个状态就是死亡后不消除，而且优先显示级别与死亡相同呢?

BCJT 发表于 2018-5-9 09:55
SV里敌人死亡的动作设置问题
1.默认的敌人死亡动作是"崩溃"，是透明显示图片且不显示影子的 ；可能你又定义 ...

我的敌人被打死，还是渐变消失那种，应该是你说的崩溃，可是我看不懂。。。 指条活路吧~

RUBY 代码复制

#==============================================================================
# ■ Sideview Ver100
#------------------------------------------------------------------------------
# 　サイドビューバトラーを管理するクラスです。
#==============================================================================
class SideView
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数　
  #--------------------------------------------------------------------------
  attr_accessor   :x                    # 画面X座標
  attr_accessor   :y                    # 画面Y座標
  attr_accessor   :z                    # 画面Z座標
  attr_accessor   :h                    # 高さ座標
  attr_accessor   :j                    # ジャンプ座標
  attr_accessor   :c                    # カーブ座標
  attr_accessor   :ox                   # 横原点
  attr_accessor   :oy                   # 縦原点
  attr_accessor   :oy_adjust            # 縦原点補正
  attr_accessor   :angle                # 回転角度
  attr_accessor   :zoom_x               # 横の拡大率
  attr_accessor   :zoom_y               # 縦の拡大率
  attr_accessor   :pattern_w            # セル横位置（矩形内）
  attr_accessor   :pattern_h            # セル縦位置（矩形内）
  attr_accessor   :sx                   # セル横位置（画像全体）
  attr_accessor   :sy                   # セル縦位置（画像全体）
  attr_accessor   :pattern_type         # セル更新タイプ
  attr_accessor   :pattern_time         # セル更新間隔
  attr_accessor   :graphic_name         # バトラー画像ファイル名
  attr_accessor   :graphic_file_index   # バトラー画像ファイル名インデックス
  attr_accessor   :graphic_index        # バトラー画像インデックス
  attr_accessor   :cw                   # セル横矩形
  attr_accessor   :ch                   # セル縦矩形
  attr_accessor   :shadow_visible       # 影表示
  attr_accessor   :weapon_visible       # 武器表示
 
  attr_accessor   :wait                 # 次の動作待ち時間
  attr_accessor   :weapon_index         # 表示中の武器画像インデックス配列
  attr_accessor   :weapon_end           # 武器アニメ終了フラグ
  attr_accessor   :force_action         # 強制アクション
  attr_accessor   :target_battler       # ターゲットバトラー情報
  attr_accessor   :second_targets       # セカンドターゲット情報
  attr_accessor   :m_a_targets          # アニメ飛ばしターゲット情報
  attr_accessor   :individual_targets   # 個別処理ターゲットバトラー情報
  attr_accessor   :effect_data          # エフェクトデータ
  attr_accessor   :anime_id             # アニメID配列
  attr_accessor   :anime_move_id        # 飛ばしアニメID配列
  attr_accessor   :mirror               # 反転フラグ
  attr_accessor   :opacity              # 透明度
  attr_accessor   :opacity_data         # 透明度操作情報
  attr_accessor   :set_damage           # バトルシーンでのダメージ処理
  attr_accessor   :m_a_data             # アニメ飛ばし情報
  attr_accessor   :m_a_starter          # アニメ飛ばし開始ターゲット情報
  attr_accessor   :action_end           # バトルシーンでの行動終了
  attr_accessor   :damage_anime_data    # ダメージ戦闘アニメのデータ
  attr_accessor   :anime_no_mirror      # 戦闘アニメの反転禁止フラグ
  attr_accessor   :anime_horming        # 戦闘アニメのホーミングフラグ
  attr_accessor   :anime_camera_zoom    # 戦闘アニメがカメラに合わせて拡大縮小するか
  attr_accessor   :anime_plus_z         # 戦闘アニメZ座標補正
  attr_accessor   :derivation_skill_id  # スキル派生ID
  attr_accessor   :immortal             # 不死身フラグ
  attr_accessor   :mirage               # 残像データ
  attr_accessor   :balloon_data         # ふきだしデータ
  attr_accessor   :timing               # 別バトラーからのタイミングデータ
  attr_accessor   :timing_targets       # タイミングデータを渡す別バトラー
  attr_accessor   :color_set            # 色調変更データ
  attr_accessor   :color                # 色調データ
  attr_accessor   :change_up            # 画像変更フラグ
  attr_accessor   :hit                  # 被攻撃回数
  attr_accessor   :add_state            # 何度も付加ステートの表示を防ぐフラグ
  attr_accessor   :counter_id           # カウンター時のスキルID
  attr_accessor   :reflection_id        # 魔法反射時のアニメID
  attr_accessor   :result_damage        # ターン終了時のHP変動データ
  attr_accessor   :active               # 行動権
  attr_accessor   :anime_off            # 戦闘アニメ消去
  attr_accessor   :command_action       # コマンドアクションフラグ
 
  attr_accessor   :base_x               # 初期位置 X座標
  attr_accessor   :base_y               # 初期位置 Y座標
  attr_accessor   :base_h               # 初期位置 高さ座標
  attr_accessor   :max_pattern_w        # セルの横分割数
  attr_accessor   :max_pattern_h        # セルの縦分割数
 
  attr_reader     :collapse             # コラプスフラグ
  attr_reader     :picture              # ピクチャ表示フラグ
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(battler)
    @battler = battler
    reset
  end
  #--------------------------------------------------------------------------
  # ● 初期化
  #--------------------------------------------------------------------------
  def reset
    @x = 0
    @y = 0
    @z = 0
    @h = 0
    @j = 0
    @c = 0
    @jump = []
    @curve = []
    @ox = 0
    @oy = 0
    @oy_adjust = 0
    @z_plus = 0
    @move_time = 0
    @angle = 0
    @angle_time = 0
    @zoom_x = 1
    @zoom_y = 1
    @zoom_time = 0
    @pattern_w = 0
    @pattern_h = 0
    @sx = 0
    @sy = 0
    @pattern_type = 0
    @pattern_time = 0
    @pattern_rest_time = 0
    @graphic_name = ""
    @graphic_file_index = ""
    @graphic_index = 0
    @cw = 0
    @ch = 0
    @shadow_visible = false
    @weapon_visible = true
 
    @wait = 0
    @weapon_index = []
    @weapon_end = true
    @full_action = []
    @action = []
    @force_action = ""
    @target_battler = []
    @second_targets = []
    @individual_targets = []
    @m_a_targets = []
    @effect_data = []
    @anime_id = []
    @anime_move_id = []
    @opacity = 255
    @opacity_data = []
    @set_damage = false
    @m_a_data = []
    @m_a_starter = []
    @action_end = false
    @damage_anime_data = []
    @anime_no_mirror = false
    @anime_horming = false
    @anime_camera_zoom = false
    @anime_plus_z = true
    @derivation_skill_id = 0
    @immortal = false
    @mirage = []
    @play_data = []
    @balloon_data = []
    @picture = false
    @timing = []
    @timing_targets = []
    @color_set = []
    @color = []
    @change_up = false
    @non_motion = false
    @graphics_change = false
    @hit = []
    @add_state = []
    @collapse = false
    @counter_id = 0
    @reflection_id = 0
    @result_damage = [0,0]
    @active = false
    @anime_off = false
    @command_action = false
 
    @base_x = 0
    @base_y = 0
    @base_z = 0
    @base_h = 0
    @max_pattern_w = 0
    @max_pattern_h = 0
    @pattern_kind = 0
    @pattern_count = 0
    @move_time = 0
    @mirror = false
    @battler.set_graphic(@pre_change_data[0], @pre_change_data[1], @pre_change_data[2], @pre_change_data[3]) if @pre_change_data != nil
    @pre_change_data = nil
  end  
  #--------------------------------------------------------------------------
  # ● セットアップ
  #--------------------------------------------------------------------------
  def setup(bitmap_width, bitmap_height, first_action_flag)
    reset if first_action_flag
    set_data
    set_base_position if !@graphics_change
    set_graphics(bitmap_width, bitmap_height)
    set_target
    setup_graphics_change if @graphics_change
    first_battler_anime_set if first_action_flag
  end  
  #--------------------------------------------------------------------------
  # ● バトラーデータ取得
  #--------------------------------------------------------------------------
  def set_data
    return if @battler == nil
    if @battler.actor?
      @graphic_name = @battler.character_name
      @graphic_index = @battler.character_index
    else
      @graphic_name = @battler.battler_name
      @graphic_index = 0
    end
    @max_pattern_w = max_pattern[0]
    @max_pattern_h = max_pattern[1]
  end
  #--------------------------------------------------------------------------
  # ● ベース座標をセット data = [X軸, Y軸, H軸]  moment_set…瞬間配置
  #--------------------------------------------------------------------------
  def set_base_position(moment_set = true)
    mirroring_reset
    if @battler.actor?
      data = N03::ACTOR_POSITION[@battler.index].dup
      @base_x = data[0] * 100 if !@mirror
      @base_x = (Graphics.width - data[0]) * 100 if @mirror
    else
      data = [@battler.screen_x, @battler.screen_y, 0].dup
      @base_x = data[0] * 100 if !$sv_camera.mirror
      @base_x = (Graphics.width - data[0]) * 100 if $sv_camera.mirror
    end
    @base_y = data[1] * 100
    @base_h = data[2] * 100
    @base_z = @y
    return if !moment_set
    @x = @base_x 
    @y = @base_y
    @z = @base_z
  end
  #--------------------------------------------------------------------------
  # ● グラフィックデータ取得
  #--------------------------------------------------------------------------
  def set_graphics(bitmap_width, bitmap_height)
    sign = @graphic_name[/^[\!\$]./]
    if sign && sign.include?('$')
      @cw = bitmap_width / @max_pattern_w
      @ch = bitmap_height / @max_pattern_h
    elsif @max_pattern_w == 1 && @max_pattern_h == 1
      @cw = bitmap_width
      @ch = bitmap_height
    else
      @cw = bitmap_width / (@max_pattern_w * 4)
      @ch = bitmap_height / (@max_pattern_h * 2)
    end
    @ox = @cw / 2
    @oy = @ch
    @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
    @sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch
  end
  #--------------------------------------------------------------------------
  # ● ターゲットをセット
  #--------------------------------------------------------------------------
  def set_target(target = nil)
    @target_battler = target
    @target_battler = [@battler] if target == nil
    @second_targets = @target_battler
  end
  #--------------------------------------------------------------------------
  # ● 画像変更用のセットアップ
  #--------------------------------------------------------------------------
  def setup_graphics_change
    @graphics_change = false
    @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
    @sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch
  end  
  #--------------------------------------------------------------------------
  # ● 戦闘開始時の待機アニメ画像データ取得
  #--------------------------------------------------------------------------
  def first_battler_anime_set
    loop do
      update
      break if @action_data == nil
      break if @action_data[0] == "motion"
      break if @action_data[0] == "move" && @action_data[8] != ""
      break if @full_action == []
    end
    start_action(first_action) if @battler.movable?
  end
  #--------------------------------------------------------------------------
  # ● アクション開始
  #--------------------------------------------------------------------------
  def start_action(kind = nil)
    return if @event_fix && $game_troop.interpreter.running?
    # ウェイト中の場合キャンセル
    return @wait -= 1 if @wait > 0 && kind == nil
    action_setup(false) if kind != nil
    set_action(kind)
    @action = kind if @action == nil
    # 行動配列が無い場合は行動終了処理へ移行
    action_terminate if @action == nil
    # 次のアクション決定
    @action_data = N03::ACTION[@action]
    next_action
  end
  #--------------------------------------------------------------------------
  # ● 行動パラメータの初期化
  #--------------------------------------------------------------------------
  def action_setup(reset = true)
    @event_fix = false
    @set_damage = false
    @action_end = false
    @balloon_data = []
    @loop_act = []
    angle_reset if reset
    zoom_reset if reset
    opacity_reset if reset
    @curve = []
    @c = 0
    convert_jump
  end  
  #--------------------------------------------------------------------------
  # ● 行動終了処理
  #--------------------------------------------------------------------------
  def action_terminate
    @mirage = [] if @mirage_end
    mirroring_reset
    @picture = false
    @individual_targets = []
    action_setup if @active
    action_setup(false) if !@active
    # 待機アクションへ移行
    stand_by_action if !@non_motion
    # 戦闘行動のアクティブ権を終了
    next_battler
  end  
  #--------------------------------------------------------------------------
  # ● 新しいアクション内容の決定
  #--------------------------------------------------------------------------
  def set_action(kind = nil)
    full_act = N03::FULLACTION[kind]
    @full_action = full_act.dup if full_act != nil
    @action = @full_action.shift
    # 参照したアクションがフルアクションであれば全体のアクションを統合
    full_act2 = N03::FULLACTION[@action]
    @full_action = full_act2.dup + @full_action if full_act2 != nil
  end
  #--------------------------------------------------------------------------
  # ● 次のアクションへ
  #--------------------------------------------------------------------------
  def next_action
    @wait = 0
    # ショートカット確認
    eval(@action) if @action != nil && @action_data == nil && N03::FULLACTION[@action] == nil
    # ウエイト設定
    @wait = @action.to_i if @wait == 0 && @action_data == nil
    @wait = rand(@wait.abs + 1) if @wait < 0
    # アクション開始
    action_play
  end
  #--------------------------------------------------------------------------
  # ● 待機アクションへ移行
  #--------------------------------------------------------------------------
  def stand_by_action
    # 通常待機に
    stand_by_act = normal
    # HPが1/4でピンチアクションに
    stand_by_act = pinch if @battler.hp <= @battler.mhp / 4
    # ステートチェック
    stand_by_act = state(@battler.states[0].id) if @battler.states[0] != nil && state(@battler.states[0].id) != nil
    # コマンドチェック
    stand_by_act = command if @command_action && command != nil
    set_action(stand_by_act)
    @action = stand_by_act if @action == nil
  end
  #--------------------------------------------------------------------------
  # ● 強制アクション開始
  #--------------------------------------------------------------------------
  def start_force_action
    return if @active
    start_action(@force_action)
    @force_action = ""
  end  
  #--------------------------------------------------------------------------
  # ● アクション追加
  #--------------------------------------------------------------------------
  def add_action(kind)
    @full_action.push(kind)
  end  
  #--------------------------------------------------------------------------
  # ● アクションの挿入
  #--------------------------------------------------------------------------
  def unshift_action(kind)
    @full_action.unshift(kind)
  end  
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
    # アクション開始
    start_action
    # 強制アクション開始
    start_force_action if @force_action != ""
    # アニメパターン更新
    update_pattern
    # 移動更新
    update_move
    # 回転更新
    update_angle if @angle_time != 0
    # 拡大縮小更新
    update_zoom if @zoom_time != 0
    # 透明度更新
    update_opacity if @opacity_data != []
  end
  #--------------------------------------------------------------------------
  # ● アニメパターン更新
  #--------------------------------------------------------------------------
  def update_pattern
    return @pattern_rest_time -= 1 if @pattern_rest_time != 0
    return if @max_pattern_w == 1 && @max_pattern_h == 1
    @pattern_rest_time = @pattern_time
    # 再生開始・終了セル位置を取得
    if @pattern_kind > 0 # 通常再生中
      @pattern_start = 0
      @pattern_end = @max_pattern_w - 1
    elsif @pattern_kind < 0 # 逆転再生中
      @pattern_start = @max_pattern_w - 1
      @pattern_end = 0
    end
    # 片道の再生が終了
    @pattern_count += 1 if @pattern_w == @pattern_end && @pattern_kind != 0
    # ループ処理
    case @pattern_type.abs
    when  1,3 # 片道
      @pattern_kind =  0 if @pattern_count != 0 && @pattern_type ==  1
      @pattern_kind =  0 if @pattern_count != 0 && @pattern_type == -1
      @pattern_kind =  1 if @pattern_count != 0 && @pattern_type ==  3
      @pattern_kind = -1 if @pattern_count != 0 && @pattern_type == -3
      @pattern_w = @pattern_start - @pattern_kind if @pattern_count != 0 && @pattern_type.abs == 3
      @pattern_count = 0
    when  2,4 # 往復
      @pattern_kind = -1 if @pattern_count == 1 && @pattern_type ==  2
      @pattern_kind =  1 if @pattern_count == 1 && @pattern_type == -2
      @pattern_kind =  0 if @pattern_count == 2 && @pattern_type ==  2
      @pattern_kind =  0 if @pattern_count == 2 && @pattern_type == -2
      @pattern_kind = -1 if @pattern_count == 1 && @pattern_type ==  4
      @pattern_kind =  1 if @pattern_count == 1 && @pattern_type == -4
      @pattern_kind =  1 if @pattern_count == 2 && @pattern_type ==  4
      @pattern_kind = -1 if @pattern_count == 2 && @pattern_type == -4
      @pattern_count = 0 if @pattern_count == 2
    end
    # セル更新
    @pattern_w += 1 * @pattern_kind
    @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
  end
  #--------------------------------------------------------------------------
  # ● 移動の更新
  #--------------------------------------------------------------------------
  def update_move
    @z = @y / 100 + @z_plus
    return if @move_time == 0
    target_position_set if @horming_move
    @x = (@x * (@move_time - 1) + @target_x) / @move_time
    @y = (@y * (@move_time - 1) + @target_y) / @move_time
    @h = (@h * (@move_time - 1) + @target_h) / @move_time if @move_h != nil
    @c += @curve[@move_time - 1] if @curve[@move_time - 1] != nil
    @j += @jump[@move_time - 1] if @jump[@move_time - 1] != nil
    @move_time -= 1
    convert_jump if @move_time == 0
  end
  #--------------------------------------------------------------------------
  # ● 移動目標の更新
  #--------------------------------------------------------------------------
  def target_position_set
    target_position = N03.get_targets_position(@move_targets, @horming_move)
    @target_x = target_position[0] + @move_x
    @target_y = target_position[1] + @move_y
    @target_h = target_position[2] + @move_h if @move_h != nil
  end  
  #--------------------------------------------------------------------------
  # ● 回転更新
  #--------------------------------------------------------------------------
  def update_angle
    @angle += @angling
    @angle_time -= 1
    return if @angle_time != 0
    return angle_reset if @angle_data[4] == 0
    angling(@angle_data) if @angle_data[4] == 2
  end  
  #--------------------------------------------------------------------------
  # ● 拡大縮小更新
  #--------------------------------------------------------------------------
  def update_zoom
    @zoom_x += @zooming_x
    @zoom_y += @zooming_y
    @zoom_time -= 1
    return if @zoom_time != 0
    return zoom_reset if @zoom_data[4] == 0
    zooming(@zoom_data) if @zoom_data[4] == 2
  end
  #--------------------------------------------------------------------------
  # ● 透明度更新
  #--------------------------------------------------------------------------
  def update_opacity
    @opacity += @opacity_data[2]
    @opacity_data[0] -= 1
    return if @opacity_data[0] != 0
    return if !@opacity_data[5]
    @opacity_data[2] *= -1
    @opacity_data[0] = @opacity_data[1]
  end
  #--------------------------------------------------------------------------
  # ● アクション実行
  #--------------------------------------------------------------------------
  def action_play 
    return if @action_data == nil
    action = @action_data[0]
    # バトラー反転の場合
    return mirroring                    if action == "mirror"
    # 残像の場合
    return mirage_set                   if action == "mirage"
    # 回転の場合  
    return angling                      if action == "angle"
    # 拡大縮小の場合  
    return zooming                      if action == "zoom"
    # 透明度操作の場合  
    return set_opacity                  if action == "opacity"
    # バトラーアニメの場合
    return battler_anime                if action == "motion"
    # 移動の場合
    return move                         if action == "move"
    # 武器アニメの場合
    return weapon_anime([@action_data]) if action == "wp"
    # アニメ飛ばしの場合
    return move_anime                   if action == "m_a"
    # 戦闘シーン通信の場合(コラプス)
    return set_play_data                if action == "collapse" or action == "no_collapse"
    # データベース戦闘アニメ表示の場合  
    return battle_anime                 if action == "anime"
    # カメラワークの場合
    return camera                       if action == "camera"
    # 画面のシェイクの場合
    return shake                        if action == "shake"
    # 画面色調変更の場合
    return color_effect                 if action == "color"
    # トランジションの場合
    return transition                   if action == "ts"
    # ふきだしアニメ表示の場合  
    return balloon_anime                if action == "balloon"
    # ピクチャ表示の場合
    return picture_set                  if action == "pic"
    # ステート操作の場合
    return state_set                    if action == "sta"
    # FPS変更の場合
    return fps                          if action == "fps"
    # バトラー画像変更の場合  
    return graphics_change              if action == "change"
    # スキル派生の場合  
    return derivating_skill             if action == "der"
    # BGM/BGS/SE演奏の場合  
    return sound                        if action == "sound"
    # ムービー再生の場合  
    return movie                        if action == "movie"
    # ゲームスイッチ操作の場合  
    return switches                     if action == "switch"
    # ゲーム変数操作の場合  
    return variable                     if action == "variable"
    # 条件分岐(ゲームスイッチ)の場合
    return nece_1                       if action == "n_1"
    # 条件分岐(ゲーム変数)の場合
    return nece_2                       if action == "n_2"
    # 条件分岐(ステート)の場合
    return nece_3                       if action == "n_3"
    # 条件分岐(スキル)の場合
    return nece_4                       if action == "n_4"
    # 条件分岐(パラメータ)の場合
    return nece_5                       if action == "n_5"
    # 条件分岐(装備)の場合
    return nece_6                       if action == "n_6"
    # 条件分岐(スクリプト)の場合
    return nece_7                       if action == "n_7"
    # セカンドターゲット操作の場合  
    return second_targets_set           if action == "s_t"
    # コモンイベント呼び出しの場合  
    return call_common_event            if action == "common"
    # 戦闘アニメ消去の場合  
    return @anime_off = true            if action == "anime_off"
    # 強制戦闘終了の場合  
    return BattleManager.process_abort  if action == "battle_end"
    # 画面固定の場合  
    return Graphics.freeze              if action == "graphics_freeze"
    # ダメージアニメの場合  
    return damage_anime                 if action == "damage_anime"
    # 武器消去の場合  
    return @weapon_visible = false      if action == "weapon_off"
    # 武器消去解除の場合  
    return @weapon_visible = true       if action == "weapon_on"
    # 待機キャンセルの場合
    return @non_motion = true           if action == "non_motion"
    # 待機キャンセル解除の場合
    return @non_motion = false          if action == "non_motion_cancel"
    # 初期位置変更の場合
    return change_base_position         if action == "change_base_position"
    # 初期位置変更解除の場合
    return set_base_position(false)     if action == "set_base_position"
    # 強制アクションの場合  
    return force_act                    if action == "force_action"
    # 強制アクションの場合 (セカンドターゲット)
    return force_act2                   if action == "force_action2"
    # 個別開始の場合
    return individual_start             if action == "individual_start"
    # 個別終了の場合
    return individual_end               if action == "individual_end"
    # ループ開始の場合
    return loop_start                   if action == "loop_start"
    # ループ終了の場合
    return loop_end                     if action == "loop_end"
    # 自分のみ更新の場合
    return only_action_on               if action == "only_action_on"
    # 自分のみ更新解除の場合
    return only_action_off              if action == "only_action_off"
    # 次の行動者へ移行の場合
    return next_battler                 if action == "next_battler"
    # 画像変更フラグの場合
    return set_change                   if action == "set_change"
    # スクリプト操作の場合   
    return eval(@action_data[0])
  end
  #--------------------------------------------------------------------------
  # ● バトラー反転実行
  #--------------------------------------------------------------------------
  def mirroring
    @mirror = !@mirror
  end  
  #--------------------------------------------------------------------------
  # ● 反転初期化
  #--------------------------------------------------------------------------
  def mirroring_reset
    @mirror = false
    mirroring if !@battler.actor? && N03::ENEMY_MIRROR
    mirroring if $sv_camera.mirror
  end  
  #--------------------------------------------------------------------------
  # ● 残像実行
  #--------------------------------------------------------------------------
  def mirage_set
    @mirage = @action_data.dup
    @mirage_end = @mirage[3]
    @mirage = [] if @mirage[1] == 0
  end  
  #--------------------------------------------------------------------------
  # ● 回転実行
  #--------------------------------------------------------------------------
  def angling(data = @action_data)
    @angle_data = data.dup
    @oy = @ch / 2
    @oy_adjust = @ch * 50
    @angle_time = data[1]
    start_angle = data[2] * N03.mirror_num(@mirror)
    end_angle = data[3] * N03.mirror_num(@mirror)
    # 時間が0以下なら即座に最終角度へ
    @angle_time = 1 if @angle_time <= 0
    # 回転時間から1フレームあたりの角度を出す
    @angling = (end_angle - start_angle) / @angle_time
    # 割り切れない余りを初期角度に
    @angle = (end_angle - start_angle) % @angle_time + start_angle
  end 
  #--------------------------------------------------------------------------
  # ● 回転初期化
  #--------------------------------------------------------------------------
  def angle_reset
    @oy = @ch
    @angle = @angle_time = @oy_adjust = 0
  end  
  #--------------------------------------------------------------------------
  # ● 拡大縮小実行
  #--------------------------------------------------------------------------
  def zooming(data = @action_data)
    @zoom_data = data.dup
    @zoom_time = data[1]
    start_zoom_x = data[2][0]
    start_zoom_y = data[2][1]
    end_zoom_x = data[3][0]
    end_zoom_y = data[3][1]
    # 時間が0以下なら即座に最終サイズへ
    @zoom_time = 1 if @zoom_time <= 0
    # 拡大縮小時間から1フレームあたりの拡大縮小率を出す
    @zooming_x = (end_zoom_x - start_zoom_x) / @zoom_time
    @zooming_y = (end_zoom_y - start_zoom_y) / @zoom_time
    # 開始サイズに
    @zoom_x = start_zoom_x
    @zoom_y = start_zoom_y
  end  
  #--------------------------------------------------------------------------
  # ● 拡大縮小初期化
  #--------------------------------------------------------------------------
  def zoom_reset
    @zoom_x = @zoom_y = 1
    @zoom_time = 0
  end  
  #--------------------------------------------------------------------------
  # ● バトラー透明度操作
  #--------------------------------------------------------------------------
  def set_opacity
    data = @action_data.dup
    @opacity = data[2]
    opacity_move = (data[3] - data[2])/ data[1]
    @opacity_data = [data[1], data[1], opacity_move, data[4], data[5], data[6]]
    @wait = data[1] if data[7]
    @wait *= 2 if data[6] && data[7]
  end 
  #--------------------------------------------------------------------------
  # ● 透明度操作初期化
  #--------------------------------------------------------------------------
  def opacity_reset
    @opacity = 255
    @opacity = 0 if @battler.hidden?
    @opacity_data = []
  end
  #--------------------------------------------------------------------------
  # ● バトラーアニメ実行
  #--------------------------------------------------------------------------
  def battler_anime(anime_data = nil)
    anime_data = @action_data.dup if anime_data == nil
    @graphic_file_index = anime_data[1] if !graphic_fix
    @pattern_h = anime_data[2]
    @pattern_w = anime_data[3]
    @pattern_h = 0 if @max_pattern_w == 1
    @pattern_w = 0 if @max_pattern_h == 1
    @pattern_type = anime_data[4]
    @pattern_time = anime_data[5]
    @pattern_rest_time = anime_data[5]
    @pattern_count = 0
    @pattern_kind = 1
    @pattern_kind = -1 if @pattern_type < 0
    @pattern_kind = 0 if @pattern_type == 0
    @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
    @sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch
    @z_plus = anime_data[6]
    @wait = set_anime_wait if anime_data[7]
    @shadow_visible = anime_data[8]
    weapon_anime(anime_data)
  end
  #--------------------------------------------------------------------------
  # ● アニメウエイト計算
  #--------------------------------------------------------------------------
  def set_anime_wait
    if @pattern_type > 0
      pattern_time_a = @max_pattern_w - @pattern_w.abs
    elsif @pattern_type < 0
      pattern_time_a = @pattern_w.abs + 1
    else
      return @pattern_time if @pattern_type == 0
    end
    case @pattern_type
    when 1,-1, 3,-3
      return pattern_time_a * @pattern_time 
    when 2,-2, 4,-4
      return pattern_time_a * @pattern_time + (@max_pattern_w - 2) * @pattern_time
    end
  end  
  #--------------------------------------------------------------------------
  # ● 移動実行
  #--------------------------------------------------------------------------
  def move
    @move_targets = N03.get_targets(@action_data[1].abs, @battler)
    return if @move_targets == []
    @move_targets = [@battler] if @action_data[1].abs == 7
    @move_x = @action_data[2] * 100 * N03.mirror_num(@mirror)
    @move_y = @action_data[3] * 100
    @move_h = @action_data[4] * 100 if @action_data[4] != nil
    @move_h = nil if @action_data[4] == nil
    battler_anime(N03::ACTION[@action_data[8]].dup) if N03::ACTION[@action_data[8]] != nil
    @horming_move = true
    @horming_move = false if @action_data[1] < 0 or @action_data[1].abs == 7
    target_position_set
    target_position = [@target_x, @target_y, @target_z]
    distanse_move = @action_data[5] > 0
    @move_time = N03.distanse_calculation(@action_data[5].abs, target_position, [@x, @y, @z], distanse_move)
    @wait = @move_time
    curve
    jump
    @move_time = 1 if @move_time == 0
    @horming_move = false if !@move_targets or @move_targets.include?(@battler)
    update_move if @move_time == 1
  end  
  #--------------------------------------------------------------------------
  # ● カーブ実行 
  #--------------------------------------------------------------------------
  def curve
    @c = 0
    return if @action_data[6] == 0
    @curve = N03.parabola([@action_data[6], -@action_data[6]], @move_time, 100, 4)
  end  
  #--------------------------------------------------------------------------
  # ● ジャンプ実行
  #--------------------------------------------------------------------------
  def jump
    convert_jump
    return if @action_data[7] == [0,0]
    @jump = N03.parabola(@action_data[7].dup, @move_time, 100)
  end  
  #--------------------------------------------------------------------------
  # ● J座標(ジャンプ高度)をH座標に変換
  #--------------------------------------------------------------------------
  def convert_jump
    @h += @j
    @j = 0
    @jump = []
  end  
  #--------------------------------------------------------------------------
  # ● データベース戦闘アニメ実行
  #--------------------------------------------------------------------------
  def battle_anime
    data = @action_data.dup
    targets = N03.get_targets(data[2], @battler)
    return if targets == []
    data[8] = !data[8] if @mirror
    @set_damage           = data[5]
    @damage_anime_data[0] = N03.get_attack_anime_id(data[1], @battler)
    @damage_anime_data[1] = data[8]
    @damage_anime_data[2] = data[7]
    @damage_anime_data[3] = data[6]
    @damage_anime_data[4] = data[9]
    @wait = N03.get_anime_time(@damage_anime_data[0]) - 2 if data[4]
    return if @set_damage
    for target in targets do display_anime(targets, target, data) end
  end
  #--------------------------------------------------------------------------
  # ● 武器アニメ開始
  #--------------------------------------------------------------------------
  def weapon_anime(anime_data)
    @weapon_end = true
    for i in 9...anime_data.size
      set_effect_data(anime_data[i]) if anime_data[i] != ""
    end
  end
  #--------------------------------------------------------------------------
  # ● アニメ飛ばし開始
  #--------------------------------------------------------------------------
  def move_anime
    @m_a_starter = []
    @m_a_targets = []
    starters = N03.get_targets(@action_data[2], @battler)
    targets = N03.get_targets(@action_data[3], @battler)
    return if starters == [] or targets == []
    single_start = true if starters != nil && @action_data[2] < 0
    single_start = true if @action_data[1][0] != 0 && $data_animations[N03.get_attack_anime_id(@action_data[1][0], @battler)].position == 3
    starters = [starters[0]] if single_start
    single_end = true if targets != nil && @action_data[3] < 0
    single_end = true if @action_data[1][1] != 0 && $data_animations[N03.get_attack_anime_id(@action_data[1][1], @battler)].position == 3
    targets = [targets[0]] if single_end
    se_flag = true
    for starter in starters
      for target in targets
        data = @action_data.dup
        data[17] = se_flag
        @effect_data.push(data)
        @m_a_targets.push(target)
        @m_a_starter.push(starter)
        se_flag = false
      end
    end  
  end
  #--------------------------------------------------------------------------
  # ● スプライトセット通信
  #--------------------------------------------------------------------------
  def set_effect_data(data = @action)
    action_data = N03::ACTION[data]
    return if action_data == nil
    @effect_data.push(action_data.dup)
  end
  #--------------------------------------------------------------------------
  # ● 戦闘シーン通信のデータを格納
  #--------------------------------------------------------------------------
  def set_play_data(data = @action_data)
    @play_data = data.dup
  end
  #--------------------------------------------------------------------------
  # ● 戦闘アニメの表示
  #--------------------------------------------------------------------------
  def display_anime(targets, target, data)
    return if !N03.first_of_all_screen_anime(data[1], target, targets)
    target.animation_id         = N03.get_attack_anime_id(data[1], @battler)
    target.animation_mirror     = data[8]
    target.sv.anime_horming     = data[3]
    target.sv.anime_camera_zoom = data[6]
    target.sv.anime_no_mirror   = data[7]
    target.sv.anime_plus_z      = data[9]
  end
  #--------------------------------------------------------------------------
  # ● 戦闘アニメ拡張データの初期化
  #--------------------------------------------------------------------------
  def reset_anime_data
    @anime_no_mirror = false
    @anime_horming = false
    @anime_camera_zoom = false
    @timing_targets = []
    @anime_plus_z = true
  end  
  #--------------------------------------------------------------------------
  # ● カメラワーク
  #--------------------------------------------------------------------------
  def camera
    data = @action_data.dup
    N03.camera(@battler, data)
    @wait = data[4] if data[5]
  end  
  #--------------------------------------------------------------------------
  # ● 画面のシェイク
  #--------------------------------------------------------------------------
  def shake
    data = @action_data.dup
    $sv_camera.shake(data[1], data[2], data[3])
    @wait = data[3] if data[4]
  end 
  #--------------------------------------------------------------------------
  # ● 画面色調変更
  #--------------------------------------------------------------------------
  def color_effect
    case @action_data[1]
    when 0,1,2,3,4,5
      targets = N03.get_targets(@action_data[1], @battler)
    when 6
      screen = true
    when 7
      targets = [@battler] + @target_battler
    when 8
      screen = true
      targets = $game_troop.members + $game_party.battle_members - [@battler]
    when 9
      screen = true
      targets = $game_troop.members + $game_party.battle_members - [@battler] - @target_battler
    when 10
      screen = true
      targets = $game_troop.members + $game_party.battle_members
    end
    return if screen == nil && targets == []
    for target in targets do target.sv.color_set = @action_data[2] end if targets
    @wait = @action_data[2][4] if @action_data[3]
    return if !screen
    $sv_camera.color_set[1] = @action_data[2]
    $sv_camera.color_set[2] = @action_data[2]
  end  
  #--------------------------------------------------------------------------
  # ● トランジション
  #--------------------------------------------------------------------------
  def transition
    $sv_camera.perform_transition(@action_data)
  end  
  #--------------------------------------------------------------------------
  # ● ふきだしアニメ表示 
  #--------------------------------------------------------------------------
  def balloon_anime
    @balloon_data = @action_data.dup
  end  
  #--------------------------------------------------------------------------
  # ● ピクチャ表示
  #--------------------------------------------------------------------------
  def picture_set
    @picture = true
    set_effect_data
  end
  #--------------------------------------------------------------------------
  # ● ステート操作
  #--------------------------------------------------------------------------
  def state_set
    targets = N03.get_targets(@action_data[1], @battler)
    return if targets == []
    case @action_data[2]
    when 1 ; targets = [targets[rand(targets.size)]]
    when 2 ; targets -= @battler if targets.include?(@battler)
    end
    for target in targets
      for id in @action_data[4]
        target.add_state(id) if @action_data[3] == "+"
        target.remove_state(id) if @action_data[3] == "-"
      end
    end
  end 
  #--------------------------------------------------------------------------
  # ● FPS変更
  #--------------------------------------------------------------------------
  def fps
    Graphics.frame_rate = @action_data[1]
    start_action
  end
  #--------------------------------------------------------------------------
  # ● バトラー画像変更の場合
  #--------------------------------------------------------------------------
  def graphics_change
    @graphics_change = true
    return @battler.graphics_change(@action_data[3]) if !@battler.actor?
    @pre_change_data = [@battler.character_name, @battler.character_index, @battler.face_name, @battler.face_index] if @pre_change_data == nil && !@action_data[1]
    if @action_data[4] == []
      face_name = @battler.face_name
      face_index = @battler.face_index
    else
      face_name = @action_data[4][1]
      face_index = @action_data[4][0]
    end
    @battler.set_graphic(@action_data[3], @action_data[2], face_name, face_index)
  end 
  #--------------------------------------------------------------------------
  # ● スキル派生 
  #--------------------------------------------------------------------------
  def derivating_skill
    # 未修得スキルは派生不可なら
    return if !@action_data[1] && !@battler.skill_learn?($data_skills[@action_data[3]])
    # コスト不足は派生不可なら
    return if !@action_data[2] && !@battler.skill_cost_payable?($data_skills[@action_data[3]])
    # 派生
    @derivation_skill_id = @action_data[3]
    # 以降のアクションをキャンセル
    @full_action = []
  end
  #--------------------------------------------------------------------------
  # ● BGM/BGS/SE演奏
  #--------------------------------------------------------------------------
  def sound
    pitch = @action_data[2] 
    vol   = @action_data[3]
    name  = @action_data[4] 
    case @action_data[1]
    when "se"
      Audio.se_play("Audio/SE/" + name, vol, pitch)
    when "bgm"
      # 名前指定のない場合、現在のBGMを変えないように
      name = RPG::BGM.last.name if @action_data[4] == ""
      Audio.bgm_play("Audio/BGM/" + name, vol, pitch)
    when "bgs"
      name = RPG::BGS.last.name if @action_data[4] == ""
      Audio.bgs_play("Audio/BGS/" + name, vol, pitch)
    end
  end
  #--------------------------------------------------------------------------
  # ● ムービーの再生
  #--------------------------------------------------------------------------
  def movie
    Graphics.play_movie('Movies/' + @action_data[1])
  end
  #--------------------------------------------------------------------------
  # ● ゲームスイッチ操作
  #--------------------------------------------------------------------------
  def switches
    for id in @action_data[1]
      $game_switches[id] = true if id > 0
      $sv_camera.switches[id.abs] = true  if id < 0
    end
    for id in @action_data[2]
      $game_switches[id] = false if id > 0
      $sv_camera.switches[id.abs] = false  if id < 0
    end
    $sv_camera.program_check
  end
  #--------------------------------------------------------------------------
  # ● ゲーム変数操作
  #--------------------------------------------------------------------------
  def variable
    # オペランドチェック
    operand = @action_data[3]
    operand = $game_variables[@action_data[3].abs] if @action_data[3] < 0
    # 変数操作で分岐
    case @action_data[2]
    when 0 ; $game_variables[@action_data[1]] = operand  # 代入
    when 1 ; $game_variables[@action_data[1]] += operand # 加算
    when 2 ; $game_variables[@action_data[1]] -= operand # 減算
    when 3 ; $game_variables[@action_data[1]] *= operand # 乗算
    when 4 ; $game_variables[@action_data[1]] /= operand # 除算
    when 5 ; $game_variables[@action_data[1]] %= operand # 剰余
    end
  end  
  #--------------------------------------------------------------------------
  # ● 条件分岐 (ゲームスイッチ)
  #--------------------------------------------------------------------------
  def nece_1
    judgment = $game_switches[@action_data[1]] == @action_data[2] if @action_data[1] > 0
    judgment = $sv_camera.switches[@action_data[1].abs] == @action_data[2] if @action_data[1] < 0
    action_diverging(judgment, @action_data[3])
  end  
  #--------------------------------------------------------------------------
  # ● 条件分岐 (ゲーム変数)
  #--------------------------------------------------------------------------
  def nece_2
    variable = $game_variables[@action_data[1]]
    num = @action_data[2]
    num = $game_variables[@action_data[2].abs] if num < 0
    case @action_data[3]
    when 0 ; judgment = variable == num
    when 1 ; judgment = variable < num
    when 2 ; judgment = variable > num
    end  
    action_diverging(judgment, @action_data[4])
  end  
  #--------------------------------------------------------------------------
  # ● 条件分岐 (ステート)
  #--------------------------------------------------------------------------
  def nece_3
    targets = N03.get_targets(@action_data[1], @battler)
    return if targets == []
    member_num = @action_data[4]
    member_num = targets.size if @action_data[4] == 0 && targets.size > 1
    hit_count = 0
    miss_count = 0
    for target in targets
      hit_count += 1 if target.state?(@action_data[2])
      miss_count += 1 if !target.state?(@action_data[2])
    end
    case @action_data[3]
    when 0 ; judgment = hit_count >= member_num
    when 1 ; judgment = miss_count >= member_num
    end
    action_diverging(judgment, @action_data[5])
  end  
  #--------------------------------------------------------------------------
  # ● 条件分岐 (スキル)
  #--------------------------------------------------------------------------
  def nece_4
    targets = N03.get_targets(@action_data[1], @battler)
    return if targets == []
    member_num = @action_data[4]
    member_num = targets.size if @action_data[4] == 0 && targets.size > 1
    hit_count = 0
    miss_count = 0
    for target in targets
      hit_count += 1 if target.skill_learn?($data_skills[@action_data[2]]) && target.skill_conditions_met?($data_skills[@action_data[2]])
      miss_count += 1 if !target.skill_learn?($data_skills[@action_data[2]]) or !target.skill_conditions_met?($data_skills[@action_data[2]])
    end
    case @action_data[3]
    when 0 ; judgment = hit_count >= member_num
    when 1 ; judgment = miss_count >= member_num
    end
    action_diverging(judgment, @action_data[5])
  end  
  #--------------------------------------------------------------------------
  # ● 条件分岐 (パラメータ)
  #--------------------------------------------------------------------------
  def nece_5
    targets = N03.get_targets(@action_data[1], @battler)
    return if targets == []
    member_num = @action_data[5]
    member_num = targets.size if @action_data[5] == 0 && targets.size > 1
    hit_count = 0
    for target in targets
      hit_count += 1 if target.comparison_parameter([@action_data[2],@action_data[3],@action_data[4]])
    end
    judgment = hit_count >= member_num
    action_diverging(judgment, @action_data[6])
  end  
  #--------------------------------------------------------------------------
  # ● 条件分岐 (装備)
  #--------------------------------------------------------------------------
  def nece_6
    targets = N03.get_targets(@action_data[1], @battler)
    return if targets == []
    member_num = @action_data[5]
    member_num = targets.size if @action_data[5] == 0 && targets.size > 1
    hit_count = 0
    miss_count = 0
    for target in targets
      hit_count += 1 if target.comparison_equip([@action_data[2],@action_data[3]])
      miss_count += 1 if !target.comparison_equip([@action_data[2],@action_data[3]])
    end
    case @action_data[4]
    when 0 ; judgment = hit_count >= member_num
    when 1 ; judgment = miss_count >= member_num
    end
    action_diverging(judgment, @action_data[6])
  end  
  #--------------------------------------------------------------------------
  # ● 条件分岐 (スクリプト)
  #--------------------------------------------------------------------------
  def nece_7
    judgment = eval(@action_data[2])
    action_diverging(judgment, @action_data[1])
  end  
  #--------------------------------------------------------------------------
  # ● アクション分岐  
  #--------------------------------------------------------------------------
  def action_diverging(judgment, kind)
    result = 0
    if judgment
      result = 1 if kind == 1
      result = 2 if kind == 2
    else
      result = 1 if kind == 0
    end
    # ﾌﾙｱｸｼｮﾝ終了
    return @full_action = []  if result == 2
    # 次のｱｸｼｮﾝを除去
    @full_action.shift if result == 1
    set_action
    # 次のｱｸｼｮﾝを実行
    @action_data = N03::ACTION[@action]
    next_action
  end
  #--------------------------------------------------------------------------
  # ● セカンドターゲット操作
  #--------------------------------------------------------------------------
  def second_targets_set
    targets = N03.get_targets(@action_data[1], @battler)
    for target in targets
      targets.delete(target) if @action_data[2][1] == 1 && target.index != @action_data[2][0]
      targets.delete(target) if @action_data[2][1] == 2 && target.index == @action_data[2][0].abs
      targets.delete(target) if @action_data[3] > 0 && target.id != @action_data[3]
      targets.delete(target) if @action_data[3] < 0 && target.id == @action_data[3].abs
      targets.delete(target) if @action_data[4] > 0 && !target.state?(@action_data[4])
      targets.delete(target) if @action_data[4] < 0 && target.state?(@action_data[4].abs)
      targets.delete(target) if @action_data[5] > 0 && !target.skill_conditions_met?($data_skills[@action_data[5]])
      targets.delete(target) if @action_data[5] < 0 && target.skill_conditions_met?($data_skills[@action_data[5].abs])
      targets.delete(target) if !target.comparison_parameter(@action_data[6])
      targets.delete(target) if !@action_data[7][1].include?(0) && !target.comparison_equip(@action_data[7])
    end
    return @second_targets = [] if targets.size == 0
    case @action_data[8]
    when 1 ; targets = [targets[rand(targets.size)]]
    when 2 ; targets.delete(@battler)
    end
    return @second_targets = [] if targets.size == 0
    @second_targets = targets
    case @action_data[9]
    when 0 ; return
    when 1 ; set_play_data(["second_targets_set"])
    when 2 ; set_play_data(["targets_set"])
    end
    @wait += 1
  end
  #--------------------------------------------------------------------------
  # ● コモンイベント呼び出し
  #--------------------------------------------------------------------------
  def call_common_event
    $game_temp.reserve_common_event(@action_data[1])
    $sv_camera.event = true
    @event_fix = @action_data[2]
  end
  #--------------------------------------------------------------------------
  # ● ダメージアニメ
  #--------------------------------------------------------------------------
  def damage_anime(delay_time = 12)
    anime(N03.get_attack_anime_id(-3, @battler), wait = true)
    action_play
    @wait -= delay_time
    @full_action.unshift("eval('@damage_anime_data = []
    @set_damage = true')")
  end
  #--------------------------------------------------------------------------
  # ● 通常コラプス
  #--------------------------------------------------------------------------
  def normal_collapse
    @collapse = true
    return
  end
  #--------------------------------------------------------------------------
  # ● 初期位置変更
  #--------------------------------------------------------------------------
  def change_base_position
    @base_x = @x
    @base_y = @y
    @base_h = @h
  end  
  #--------------------------------------------------------------------------
  # ● 強制アクション実行
  #--------------------------------------------------------------------------
  def force_act
    target(@full_action.shift)
  end
  #--------------------------------------------------------------------------
  # ● 強制アクション実行 (セカンドターゲット)
  #--------------------------------------------------------------------------
  def force_act2
    target2(@full_action.shift)
  end
  #--------------------------------------------------------------------------
  # ● 個別処理開始
  #--------------------------------------------------------------------------
  def individual_start
    @individual_targets = @target_battler.dup
    @remain_targets = @target_battler.dup
    @target_battler = [@individual_targets[0]]
    # リピート部分のアクションを保持
    @individual_act = @full_action.dup
  end
  #--------------------------------------------------------------------------
  # ● 個別処理終了
  #--------------------------------------------------------------------------
  def individual_end
    @individual_targets.shift
    for target in @individual_targets
      @individual_targets.shift if target.dead?
    end
    # ターゲットが残っているなら行動リピート
    return @target_battler = @remain_targets if @individual_targets.size == 0
    @full_action = @individual_act.dup
    @target_battler = [@individual_targets[0]]
  end
  #--------------------------------------------------------------------------
  # ● ループ開始
  #--------------------------------------------------------------------------
  def loop_start
    # ループ部分のアクションを保持
    @loop_act = @full_action.dup
  end
  #--------------------------------------------------------------------------
  # ● ループ終了
  #--------------------------------------------------------------------------
  def loop_end
    # 行動リピート
    @full_action = @loop_act.dup if @loop_act != []
  end
  #--------------------------------------------------------------------------
  # ● 次の行動者へ移行
  #--------------------------------------------------------------------------
  def next_battler
    @action_end = true
    @active = false
  end
  #--------------------------------------------------------------------------
  # ● 画像変更フラグ
  #--------------------------------------------------------------------------
  def set_change
    @change_up = true
  end
  #--------------------------------------------------------------------------
  # ● 戦闘シーン通信
  #--------------------------------------------------------------------------
  def play_data
    data = @play_data
    @play_data = []
    return data
  end
  #--------------------------------------------------------------------------
  # ● ショートカットコマンド
  #--------------------------------------------------------------------------
  def anime(anime_id, wait = true)
    @action_data = ["anime",anime_id,1,false,wait,false,true,false]
  end
  def anime_me(anime_id, wait = true)
    @action_data = ["anime",anime_id,0,false,wait,false,true,false]
  end
  def se(file, pitch = 100)
    @action_data = ["sound",  "se", pitch, 100, file]
  end
  def target(act)
    for target in @target_battler do target.sv.force_action = act end
  end
  def target2(act)
    for target in @second_targets do target.sv.force_action = act end
  end
  def delay(time)
    @wait = @battler.index * time
  end
  #--------------------------------------------------------------------------
  # ● バトラーのIDを取得
  #--------------------------------------------------------------------------
  def id
    return @battler.id if @battler.actor?
    return -@battler.id
  end
  #--------------------------------------------------------------------------
  # ● 被クリティカルフラグを取得
  #--------------------------------------------------------------------------
  def critical?
    return @battler.result.critical
  end
  #--------------------------------------------------------------------------
  # ● 被回復フラグを取得
  #--------------------------------------------------------------------------
  def recovery?
    recovery = false
    recovery = true if @battler.result.hp_damage < 0
    recovery = true if @battler.result.mp_damage < 0
    recovery = true if @battler.result.tp_damage < 0
    return recovery
  end
  #--------------------------------------------------------------------------
  # ● 被スキルIDを取得
  #--------------------------------------------------------------------------
  def damage_skill_id
    return @damage_skill_id
  end
  #--------------------------------------------------------------------------
  # ● 被アイテムIDを取得
  #--------------------------------------------------------------------------
  def damage_item_id
    return @damage_item_id
  end
  #--------------------------------------------------------------------------
  # ● 装備武器を取得
  #--------------------------------------------------------------------------
  def weapon_id
    return 0 if !@battler.weapons[0]
    return @battler.weapons[0].id
  end
  #--------------------------------------------------------------------------
  # ● 装備武器のタイプを取得
  #--------------------------------------------------------------------------
  def weapon_type
    return 0 if !@battler.weapons[0]
    return @battler.weapons[0].wtype_id
  end
  #--------------------------------------------------------------------------
  # ● 盾を装備しているか
  #--------------------------------------------------------------------------
  def shield?
    for armor in @battler.armors do return true if armor != nil && armor.etype_id == 1 end
    return false
  end
  #--------------------------------------------------------------------------
  # ● ダメージがあるか
  #--------------------------------------------------------------------------
  def damage_zero?
    return @battler.result.hp_damage == 0 && @battler.result.mp_damage == 0 && @battler.result.tp_damage == 0
  end
  #--------------------------------------------------------------------------
  # ● スキルIDを取得
  #--------------------------------------------------------------------------
  def skill_id
    return @counter_id if @counter_id != 0
    return 0 if @battler.current_action == nil or @battler.current_action.item == nil
    return 0 if @battler.current_action.item.is_a?(RPG::Item)
    return @battler.current_action.item.id
  end
  #--------------------------------------------------------------------------
  # ● スキルのタイプを取得
  #--------------------------------------------------------------------------
  def skill_type
    return 0 if skill_id == 0
    return $data_skills[skill_id].stype_id
  end
  #--------------------------------------------------------------------------
  # ● スキル名を取得
  #--------------------------------------------------------------------------
  def skill_name
    return "" if skill_id == 0
    return $data_skills[skill_id].name
  end
  #--------------------------------------------------------------------------
  # ● アイテムIDを取得
  #--------------------------------------------------------------------------
  def item_id
    return 0 if @battler.current_action == nil or @battler.current_action.item == nil
    return @battler.current_action.item.id
  end
  #--------------------------------------------------------------------------
  # ● 攻撃アクション
  #--------------------------------------------------------------------------
  def attack_action(item)
    return skill_action if item.is_a?(RPG::Skill)
    return item_action
  end
  #--------------------------------------------------------------------------
  # ● ダメージアクションベース
  #--------------------------------------------------------------------------
  def damage_action_base(item)
    @damage_skill_id = 0
    @damage_item_id = 0
    @damage_skill_id = item.id if item.is_a?(RPG::Skill)
    @damage_item_id = item.id if item.is_a?(RPG::Item)
  end  
  #--------------------------------------------------------------------------
  # ● ダメージアクション 
  #--------------------------------------------------------------------------
  def damage_action(attacker, item)
    damage_action_base(item)
    act = damage(attacker)
    return if @active
    start_action(act) if act != nil
  end
  #--------------------------------------------------------------------------
  # ● 回避アクション
  #--------------------------------------------------------------------------
  def evasion_action(attacker, item)
    damage_action_base(item)
    act = evasion(attacker)
    return if @active
    start_action(act) if act != nil
  end
  #--------------------------------------------------------------------------
  # ● ミスアクション
  #--------------------------------------------------------------------------
  def miss_action(attacker, item)
    damage_action_base(item)
    act = miss(attacker)
    return if @active
    start_action(act) if act != nil
  end
  #--------------------------------------------------------------------------
  # ● 閃きスクリプト併用処理
  #--------------------------------------------------------------------------
  def flash_action
    return "閃き"
  end
 
end
 
 
#==============================================================================
# ■ module N03
#------------------------------------------------------------------------------
# 　サイドビューバトルのモジュールです。
#==============================================================================
module N03
  #--------------------------------------------------------------------------
  # ● バトラーの敵グループを取得
  #--------------------------------------------------------------------------
  def self.get_enemy_unit(battler)
    return $game_troop if battler.actor?
    return $game_party
  end
  #--------------------------------------------------------------------------
  # ● バトラーの味方グループを取得
  #--------------------------------------------------------------------------
  def self.get_party_unit(battler)
    return $game_party if battler.actor?
    return $game_troop
  end
  #--------------------------------------------------------------------------
  # ● 戦闘アニメ時間の取得
  #--------------------------------------------------------------------------
  def self.get_anime_time(anime_id)
    return 0 if anime_id <= 0
    return $data_animations[anime_id].frame_max * 4
  end
  #--------------------------------------------------------------------------
  # ● 攻撃アニメの取得
  #--------------------------------------------------------------------------
  def self.get_attack_anime_id(kind, battler)
    return $data_skills[battler.sv.counter_id].animation_id if kind == -3 && battler.sv.counter_id != 0
    case kind
    when -1 ; anime_id = battler.atk_animation_id1
    when -2 ; anime_id = battler.atk_animation_id2
    when -3
      if battler.current_action != nil
        anime_id = battler.current_action.item.animation_id if battler.current_action.item != nil
      end
    else    ; anime_id = kind
    end
    case anime_id
    when -1 ; anime_id = battler.atk_animation_id1
    when -2 ; anime_id = battler.atk_animation_id2
    end
    return anime_id if anime_id
    return 0
  end  
  #--------------------------------------------------------------------------
  # ● 戦闘アニメデータをセット
  #--------------------------------------------------------------------------
  def self.set_damage_anime_data(targets, target, data)
    return if !first_of_all_screen_anime(data[0], target, targets)
    target.animation_id         = data[0]
    target.animation_mirror     = data[1]
    target.sv.anime_no_mirror   = data[2]
    target.sv.anime_camera_zoom = data[3]
    target.sv.anime_plus_z      = data[4]
  end    
  #--------------------------------------------------------------------------
  # ● ターゲットの取得 
  #--------------------------------------------------------------------------
  def self.get_targets(kind, battler)
    case kind.abs
    when 0 ; return [battler].dup
    when 1 ; return battler.sv.target_battler.dup
    when 2 ; return get_enemy_unit(battler).members.dup
    when 3 ; return get_party_unit(battler).members.dup
    when 4 ; return $game_troop.members.dup + $game_party.battle_members.dup
    when 5 ; return battler.sv.second_targets.dup
    end
  end  
  #--------------------------------------------------------------------------
  # ● ターゲットの座標を取得
  #--------------------------------------------------------------------------
  def self.get_targets_position(targets, horming, m_a = nil)
    return [0,0,0] if targets == nil && !$sv_camera.mirror
    return [Graphics.width,0,0] if targets == nil && $sv_camera.mirror
    x = y = h = 0
    for i in 0...targets.size
      x += targets[i].sv.base_x if !horming
      y += targets[i].sv.base_y if !horming
      h += targets[i].sv.base_h if !horming
      x += targets[i].sv.x if horming
      y += targets[i].sv.y if horming
      h += targets[i].sv.h if horming
      y -= targets[i].sv.ch * 100 if m_a == 0
      y -= targets[i].sv.ch * 50 if m_a == 1
    end
    return [x / targets.size, y / targets.size, h / targets.size]
  end
  #--------------------------------------------------------------------------
  # ● 速度を時間に変換
  #--------------------------------------------------------------------------
  def self.distanse_calculation(time, target_position, self_position, distanse_move)
    return time if !distanse_move
    distanse_x = self_position[0] - target_position[0]
    distanse_x = target_position[0] - self_position[0] if target_position[0] > self_position[0]
    distanse_y = self_position[1] - target_position[1]
    distanse_y = target_position[1] - self_position[1] if target_position[1] > self_position[1]
    if self_position[2] != nil && target_position[2] != nil
      distanse_h = self_position[2] - target_position[2]
      distanse_h = target_position[2] - self_position[2] if target_position[2] > self_position[2]
    else
      distanse_h = 0
    end
    distanse = [distanse_x, distanse_y, distanse_h].max
    return distanse / (time * 100) + 1
  end
  #--------------------------------------------------------------------------
  # ● 放物線移動計算
  #--------------------------------------------------------------------------
  def self.parabola(data, time, size, type = 1)
    move_data = data
    move_data[0] *= size
    move_data[1] *= size
    move = []
    move_d = []
    for i in 0...time / 2
      move[i] = move_data[0]
      move_d[i] = move_data[1]
      move_data[0] = move_data[0] * type / (1 + type)
      move_data[1] = move_data[1] * type / (1 + type)
    end
    move = move + move_d.reverse!
    move.reverse!
    adjust = move.inject(0) {|result, item| result + item }
    move[move.size - 1] += adjust if data[0] == data[1] && adjust != 0
    move.unshift(0) if time % 2 != 0
    return move
  end
  #--------------------------------------------------------------------------
  # ● 反転値
  #--------------------------------------------------------------------------
  def self.mirror_num(mirror)
    return 1 if !mirror
    return -1
  end  
  #--------------------------------------------------------------------------
  # ● カメラワーク
  #--------------------------------------------------------------------------
  def self.camera(battler, data)
    battler = $game_party.battle_members[0] if !battler
    cx = data[2][0] * 100
    cy = data[2][1] * 100
    return $sv_camera.move(cx, cy, data[3], data[4], true) if data[1] == 6
    targets = self.get_targets(data[1], battler)
    return if targets == nil or targets == []
    position = self.get_targets_position(targets, true)
    $sv_camera.move(position[0], position[1] - position[2], data[3], data[4], false)
  end
  #--------------------------------------------------------------------------
  # ● コラプス禁止
  #--------------------------------------------------------------------------
  def self.immortaling
    # 全員に不死身付与
    for member in $game_party.battle_members + $game_troop.members
      # イベント操作等で不死身設定になっていたら解除を無効にするフラグを立てる
      member.sv.immortal = true if member.state?(N03::IMMORTAL_ID)
      member.add_state(N03::IMMORTAL_ID)
    end
    return true
  end  
  #--------------------------------------------------------------------------
  # ● コラプス許可
  #--------------------------------------------------------------------------
  def self.unimmortaling
    # 全員の不死身化解除(イベント等で不死身設定がされていれば除く)
    for member in $game_party.battle_members + $game_troop.members
      next if member.dead?
      # 不死身ステートが行動中に解除されていた場合、解除無効を解除
      member.sv.immortal = false if !member.state?(N03::IMMORTAL_ID) && member.sv.immortal
      next member.sv.immortal = false if member.sv.immortal
      member.remove_state(N03::IMMORTAL_ID)
      next if member.hp != 0
      member.add_state(1)
      member.perform_collapse_effect
      member.sv.action_terminate
    end
    return false
  end  
  #--------------------------------------------------------------------------
  # ● スキル派生
  #--------------------------------------------------------------------------
  def self.derived_skill(battler)
    battler.force_action(battler.sv.derivation_skill_id, -2)
    BattleManager.unshift_action_battlers(battler)
  end
  #--------------------------------------------------------------------------
  # ● ダメージの作成
  #--------------------------------------------------------------------------
  def self.set_damage(battler, hp_damage, mp_damage)
    battler.result.hp_damage = hp_damage
    battler.result.mp_damage = mp_damage
  end
  #--------------------------------------------------------------------------
  # ● ターゲット生死確認
  #--------------------------------------------------------------------------
  def self.targets_alive?(targets)
    return false if targets == []
    for target in targets do return true if !target.dead? end
    return false
  end
  #--------------------------------------------------------------------------
  # ● ターゲットをセカンドターゲットへ
  #--------------------------------------------------------------------------
  def self.s_targets(battler)
    battler.sv.target_battler = battler.sv.second_targets
    return battler.sv.second_targets
  end  
  #--------------------------------------------------------------------------
  # ● セカンドターゲットをターゲットへ
  #--------------------------------------------------------------------------
  def self.targets_set(battler)
    battler.sv.second_targets = battler.current_action.make_targets.compact
    battler.sv.target_battler = battler.sv.second_targets
  end  
  #--------------------------------------------------------------------------
  # ● 戦闘アニメ実行判定 (対象：画面時は最初のターゲットのみアニメ実行)
  #--------------------------------------------------------------------------
  def self.first_of_all_screen_anime(anime_id, target, targets)
    anime = $data_animations[anime_id]
    return false if !anime
    return true if anime.position != 3
    return false if anime.position == 3 && target != targets[0]
    targets.delete(target)
    target.sv.timing_targets = targets
    return true
  end
  #--------------------------------------------------------------------------
  # ● 戦闘不能付加攻撃か
  #--------------------------------------------------------------------------
  def self.dead_attack?(battler, item)
    for state in battler.atk_states
      return true if state == battler.death_state_id
    end
    for effect in item.effects
      return true if effect.code == 21 && effect.data_id == battler.death_state_id
    end
    return false
  end
end
 
#==============================================================================
# ■ Sprite_Weapon
#------------------------------------------------------------------------------
# 　ウエポン表示用のスプライトです。
#==============================================================================
class Sprite_Weapon < Sprite_Base
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数　
  #--------------------------------------------------------------------------
  attr_reader   :index                       # ウエポン画像配列のインデックス
  attr_reader   :battler                     # 画像が参照しているバトラー
  attr_reader   :move_time                   # 画像が目標に到達するまでの時間
  attr_reader   :through                     # 貫通フラグ
  attr_reader   :action_end                  # 武器アクション終了フラグ
  attr_reader   :action_end_cancel                  # 武器アクション終了フラグ
  attr_reader   :hit_position                # 画像が目標に到達した時の座標
  attr_accessor :hit_anime_id                # 画像が目標に到達した時のアニメID
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化 
  #--------------------------------------------------------------------------
  def initialize(viewport, index, battler)
    super(viewport)
    @index = index
    @battler = battler
    @position_x = @position_y = 0
    @o = 0
    @real_x = @real_y = 0
    @mirror = @battler.sv.mirror
    reset
    set_action
  end
  #--------------------------------------------------------------------------
  # ● 初期化
  #--------------------------------------------------------------------------
  def reset
    @z_plus = 0
    @weapon_data = []
    @move_data = []
    @move_x = 0
    @move_y = 0
    @orbit = []
    @through = false
    @distanse_move = false
    @weapon_width = 0
    @weapon_height = 0
    @anime_time = 0
    @anime_position = 1
    @move_time = 0
    @hit_anime_id = 0
    @move_anime = true
    @action_end = false
    @action_end_cancel = false
    reset_position
  end  
  #--------------------------------------------------------------------------
  # ● アクションをセット
  #--------------------------------------------------------------------------
  def set_action
    return if @battler.sv.effect_data == []
    weapon_anime if @battler.sv.effect_data[0][0] == "wp"
    move_anime if @battler.sv.effect_data[0][0] == "m_a"
    @battler.sv.effect_data.shift
  end
  #--------------------------------------------------------------------------
  # ● 武器アニメ実行
  #--------------------------------------------------------------------------
  def weapon_anime
    @weapon_data = @battler.sv.effect_data[0].dup
    set_graphics
    set_ox
    set_weapon_move
  end
  #--------------------------------------------------------------------------
  # ● アニメ移動実行
  #--------------------------------------------------------------------------
  def move_anime
    @move_data = @battler.sv.effect_data[0].dup
    # ターゲットを取得
    @target_battler = [@battler.sv.m_a_targets.shift]
    @target_battler = N03.get_targets(@move_data[3], @battler) if @move_data[3] < 0
    set_move
    return if @move_data[16] == ""
    weapon_data = N03::ACTION[@move_data[16]]
    return if weapon_data == nil
    @weapon_data = weapon_data.dup
    set_graphics
    set_ox
    set_weapon_move
  end
  #--------------------------------------------------------------------------
  # ● 武器画像を取得
  #--------------------------------------------------------------------------  
  def set_graphics
    # 武器に依存しない画像設定がある場合
    if @weapon_data[13] != ""
      self.bitmap = Cache.character(@weapon_data[13]).dup
      @weapon_width = self.bitmap.width
      @weapon_height = self.bitmap.height
      return
    end
    # 武器を取得
    weapon = @battler.weapons[0]
    # 逆手装備を取得
    if @weapon_data[10]
      weapon = nil
      for armor in @battler.armors do break weapon = armor if armor.is_a?(RPG::Armor) && armor.etype_id == 1 end
      weapon = @battler.weapons[1] if !weapon
    end  
    # 武器がなければ処理をキャンセル
    return if weapon == nil
    # インデックスを取得
    file_index = @weapon_data[12]
    # アイコンを利用するなら
    if @weapon_data[1] == 0
      icon_index = weapon.icon_index
      self.bitmap = Cache.system("Iconset" + file_index).dup
      self.src_rect.set(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
      @weapon_width = @weapon_height = 24
    # 独自画像指定 
    else
      file_name = @battler.sv.weapon_graphic(weapon.id, weapon.wtype_id) if weapon.is_a?(RPG::Weapon)
      file_name = @battler.sv.shield_graphic(weapon.id, weapon.atype_id) if weapon.is_a?(RPG::Armor)
      self.bitmap = Cache.character(file_name + file_index).dup
      @weapon_width = self.bitmap.width
      @weapon_height = self.bitmap.height
      return if @weapon_data[1] == 1
      # 2003仕様の武器アニメ
      @weapon_width /= @battler.sv.max_pattern[0]
    end
  end
  #--------------------------------------------------------------------------
  # ● 画像の原点を取得
  #--------------------------------------------------------------------------  
  def set_ox
    # 反転時は設定を逆に
    if @mirror
      case @weapon_data[6]
      when 1 ; @weapon_data[6] = 2 # 左上→右上に
      when 2 ; @weapon_data[6] = 1 # 右上→左上に
      when 3 ; @weapon_data[6] = 4 # 左下→右下に
      when 4 ; @weapon_data[6] = 3 # 右下→左下に
      end
    end
    # 原点を設定
    case @weapon_data[6]
    when 0 # 中心
      self.ox = @weapon_width / 2
      self.oy = @weapon_height / 2
    when 1 # 左上
      self.ox = 0
      self.oy = 0
    when 2 # 右上
      self.ox = @weapon_width
      self.oy = 0
    when 3 # 左下
      self.ox = 0
      self.oy = @weapon_height
    when 4 # 右下
      self.ox = @weapon_width
      self.oy = @weapon_height
    when 5 # バトラーと同じ
      self.ox = @weapon_width / 2
      self.oy = @weapon_height
    end
  end  
  #--------------------------------------------------------------------------
  # ● バトラーの座標を取得
  #--------------------------------------------------------------------------  
  def set_battler_position
    @position_x = @battler.sv.x + @weapon_data[3][0] * N03.mirror_num(@mirror) * 100
    @position_y = (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.c - @battler.sv.oy_adjust) + @weapon_data[3][1] * 100
    reset_position
  end
  #--------------------------------------------------------------------------
  # ● 座標を初期化
  #--------------------------------------------------------------------------  
  def reset_position
    @real_x = @position_x / 100
    @real_y = @position_y / 100
    @real_zoom_x = 1
    @real_zoom_y = 1
  end
  #--------------------------------------------------------------------------
  # ● 戦闘アニメを表示
  #--------------------------------------------------------------------------  
  def set_animation(anime_id)
    return if $data_animations[anime_id] == nil
    @anime_position = $data_animations[anime_id].position
    @horming = true
    @horming = false if @anime_position == 3
    @anime_camera_zoom = true
    @anime_no_mirror = false
    start_animation($data_animations[anime_id], @mirror)
    timings = $data_animations[anime_id].timings
  end
  #--------------------------------------------------------------------------
  # ● ヒット時の戦闘アニメ実行
  #--------------------------------------------------------------------------  
  def set_hit_animation(position_data, hit_anime_id, target)
    return if $data_animations[hit_anime_id] == nil
    @real_x = position_data[0]
    @real_y = position_data[1]
    @position_x = position_data[0] * 100
    @position_y = position_data[1] * 100
    self.z = position_data[2]
    @z_plus = 1000
    @action_end = false
    @horming = true
    set_animation(hit_anime_id)
    @anime_time = $data_animations[hit_anime_id].frame_max * 4
    @timing_targets = [target]
    @move_time = @hit_anime_id = 0
    @weapon_data = []
  end
  #--------------------------------------------------------------------------
  # ● タイミングバトラー追加
  #--------------------------------------------------------------------------  
  def timing_battler_set(target)
    @timing_targets.push(target)
  end
  #--------------------------------------------------------------------------
  # ● 武器の動きを取得
  #--------------------------------------------------------------------------  
  def set_weapon_move
    # 開始位置を取得
    set_battler_position if @move_time == 0
    @z_plus = 50 if @z_plus == 0 && @weapon_data[9]
    self.z = @battler.sv.z + @z_plus
    # 反転処理
    @mirror = !@mirror if @weapon_data[7]
    self.mirror = @mirror
    # 更新パターンをセット
    set_pattern
    @max_pattern = 2 if @max_pattern == 1
    # 動きを計算
    @weapon_move_data = []
    @weapon_angle_data = []
    @weapon_zoom_data = []
    num = N03.mirror_num(@mirror)
    for i in 0...@max_pattern
      move_data_x = @weapon_data[2][0] * num * 100 * i / (@max_pattern - 1)
      move_data_y = @weapon_data[2][1] * 100 * i / (@max_pattern - 1)
      move_angle = @weapon_data[4] * num + (@weapon_data[5] * num - @weapon_data[4] * num) * i / (@max_pattern - 1)
      move_zoom_x = 1 + (@weapon_data[8][0] - 1) * i / (@max_pattern - 1)
      move_zoom_y = 1 + (@weapon_data[8][1] - 1) * i / (@max_pattern - 1)
      @weapon_move_data.push([move_data_x, move_data_y])
      @weapon_angle_data.push(move_angle)
      @weapon_zoom_data.push([move_zoom_x, move_zoom_y])
    end
  end  
  #--------------------------------------------------------------------------
  # ● 更新パターン
  #--------------------------------------------------------------------------
  def set_pattern
    if @weapon_data[11] == -1
      return @max_pattern = @battler.sv.max_pattern[0] if @battler.sv.pattern_type != 0
      @count = @battler.sv.pattern_time
      @max_count = @battler.sv.pattern_time
      @max_pattern = @battler.sv.max_pattern[0]
      @repeat = false
    else
      @count = @weapon_data[11][0]
      @max_count = @weapon_data[11][0]
      @max_pattern = @weapon_data[11][1]
      @repeat = @weapon_data[11][2]
    end
    @pattern = 0
  end
  #--------------------------------------------------------------------------
  # ● 移動実行
  #--------------------------------------------------------------------------
  def set_move
    # 戦闘アニメを取得
    set_animation(@move_data[1][0]) if $data_animations[@move_data[1][0]] != nil && $data_animations[@move_data[1][0]].position != 3
    @anime_camera_zoom = @move_data[13]
    @loop = @move_data[14]
    @loop = false if @move_data[1][0] == 0
    @anime_no_mirror = @move_data[15]
    @se_flag = @move_data[17]
    # 開始位置を取得
    start_position
    @z_plus = 1000 if @move_data[9]
    # ターゲットバトラー画像にこのアニメのSEとタイミング設定を反映させる
    @timing_targets = @target_battler
    # 座標計算
    @move_x = @move_data[5][0] * 100 * N03.mirror_num(@mirror)
    @move_y = @move_data[5][1] * 100
    # 時間計算か速度計算か
    @distanse_move = true if @move_data[6] > 0
    @move_time = @move_data[6].abs
    # 時間0の場合、アニメが設定されていればアニメ表示時間に合わせる
    if @move_time == 0
      @move_time = $data_animations[@move_data[1][0]].frame_max * 4 if $data_animations[@move_data[1][0]]
      @move_time = 1 if !$data_animations[@move_data[1][0]]
      @distanse_move = false
    end
    # 貫通タイプの場合
    @through = true if @move_data[7] == 1
    @auto_through_flag = false
    @auto_through_flag = true if @move_data[7] == 0
    # ターゲット座標計算
    if @target_battler == nil
      @target_x = @move_x * 100
      @target_x = (Graphics.width - @move_x) * 100 if @mirror
      @target_y = @move_y * 100
    else
      move_data_set
    end
    # ターゲットに到達するまでの時間を計算
    @move_time = distanse_calculation(@move_time, @target_x, @target_y)
    # 円軌道計算
    orbit
    # バトラーのウエイト設定
    @battler.sv.wait = @move_time - 1 if @move_data[10][0]
    @move_horming = @move_data[12]
  end  
  #--------------------------------------------------------------------------
  # ● 速度を時間に変換
  #--------------------------------------------------------------------------
  def distanse_calculation(time, target_x, target_y)
    return time if !@distanse_move
    distanse_x = @position_x - @target_x
    distanse_x = @target_x - @position_x if @target_x > @position_x
    distanse_y = @position_y - @target_y
    distanse_y = @target_y - @position_y if @target_y > @position_y
    distanse = [distanse_x, distanse_y].max
    return distanse / (time * 100) + 1
  end 
  #--------------------------------------------------------------------------
  # ● 移動目標の更新
  #--------------------------------------------------------------------------
  def move_data_set
    return if @target_battler == nil
    position = N03.get_targets_position(@target_battler, true, @anime_position)
    @target_x = position[0] + @move_x
    @target_y = position[1] - position[2] + @move_y
  end 
  #--------------------------------------------------------------------------
  # ● 開始位置を計算
  #--------------------------------------------------------------------------
  def start_position
    starter = [@battler.sv.m_a_starter.shift]
    starter = N03.get_targets(@move_data[2], @battler) if @move_data[2] < 0
    position = [0, 0]
    position = N03.get_targets_position(starter, true, @anime_position) if starter != nil
    @position_x = position[0] + @move_data[4][0] * 100
    @position_y = position[1] + position[2] + @move_data[4][1] * 100
    @position_z = @position_y
  end  
  #--------------------------------------------------------------------------
  # ● 円軌道計算
  #--------------------------------------------------------------------------
  def orbit
    orbit_data = @move_data[8].dup
    orbit_data[0] *= 100
    orbit_data[1] *= 100
    orbit_d = []
    for i in 0...@move_time / 2
      @orbit[i] = orbit_data[0]
      orbit_data[0] /= 2
      orbit_d[i] = orbit_data[1]
      orbit_data[1] /= 2
    end
    @orbit = @orbit + orbit_d.reverse!
    @orbit.reverse!
  end  
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
    update_hit_anime if @anime_time != 0
    update_move if @move_time != 0
    update_weapon_move if @weapon_data != []
    update_position
    update_color
    self.visible = @battler.sv.weapon_visible
    super
  end
  #--------------------------------------------------------------------------
  # ● ヒット時の戦闘アニメ
  #--------------------------------------------------------------------------
  def update_hit_anime
    @anime_time -= 1
    @action_end = true if @anime_time == 0
  end
  #--------------------------------------------------------------------------
  # ● 移動の更新
  #--------------------------------------------------------------------------
  def update_move
    move_data_set if @move_horming && !@hit_position
    through_set(@move_time, @target_x, @target_y) if @move_time == 1 && !@hit_position
    @o += @orbit[@move_time - 1] if @orbit[@move_time - 1] != nil
    @position_x = (@position_x * (@move_time - 1) + @target_x) / @move_time
    @position_y = (@position_y * (@move_time - 1) + @target_y) / @move_time + @o
    reset_position
    set_animation(@move_data[1][0]) if @loop && !animation?
    @move_time -= 1
    return if @move_time != 0
    @action_end = true if !@action_end_cancel
  end
  #--------------------------------------------------------------------------
  # ● 武器の動きを更新
  #--------------------------------------------------------------------------
  def update_weapon_move
    pattern = update_pattern
    set_battler_position if @move_time == 0 && !@action_end_cancel
    @real_x = @position_x / 100 + @weapon_move_data[pattern][0] / 100
    @real_y = @position_y / 100 + @weapon_move_data[pattern][1] / 100
    @real_zoom_x = @weapon_zoom_data[pattern][0]
    @real_zoom_y = @weapon_zoom_data[pattern][1]
    self.angle = @weapon_angle_data[pattern]
    self.src_rect.set(@weapon_width * pattern, 0, @weapon_width, @weapon_height) if @weapon_data[1] == 2
  end
  #--------------------------------------------------------------------------
  # ● パターンを更新
  #--------------------------------------------------------------------------
  def update_pattern
    return @battler.sv.pattern_w if @count == nil
    @count -= 1
    return @pattern if @count != 0
    @count = @max_count
    @pattern += 1
    if !@repeat && @pattern == @max_pattern
      @pattern = @max_pattern - 1
    elsif @pattern == @max_pattern
      @pattern = 0
    end
    return @pattern
  end
  #--------------------------------------------------------------------------
  # ● 座標を更新
  #--------------------------------------------------------------------------
  def update_position
    self.x = (@real_x - $sv_camera.x) * $sv_camera.convert / 1000
    self.y = (@real_y - $sv_camera.y) * $sv_camera.convert / 1000
    self.x += $sv_camera.sx / 100 unless @battler.sv.h != 0 && @weapon_data != []
    self.y += $sv_camera.sy / 100 unless @battler.sv.h != 0 && @weapon_data != []
    self.z = @battler.sv.z + @z_plus - 10
    self.zoom_x = @real_zoom_x * $sv_camera.zoom
    self.zoom_y = @real_zoom_y * $sv_camera.zoom
    self.opacity = @battler.sv.opacity if @battler.sv.opacity_data[4]
  end
  #--------------------------------------------------------------------------
  # ● 貫通の処理
  #--------------------------------------------------------------------------
  def through_set(time, target_x, target_y)
    @hit_anime_id = N03.get_attack_anime_id(@move_data[1][1], @battler)
    @battler.sv.wait = N03.get_anime_time(@hit_anime_id) if @move_data[10][1]
    moving_x = (target_x / 100 - @position_x / 100) / time
    moving_y = (target_y / 100 - @position_y / 100) / time
    goal_x = $sv_camera.max_left - 100 if moving_x < 0
    goal_x = Graphics.width + $sv_camera.max_right + 100 if moving_x > 0
    goal_y = $sv_camera.max_top - 100 if moving_y < 0
    goal_y = Graphics.height + $sv_camera.max_bottom + 100 if moving_y > 0
    if goal_x == nil &&  goal_y == nil
      time = 0 
      reset_position
    else
      time = move_calculation(moving_x, moving_y, goal_x, goal_y)
    end
    target_x = @position_x + moving_x * time * 100
    target_y = @position_y + moving_y * time * 100
    @pre_data = [time, target_x, target_y]
    @battler.sv.m_a_data.push([@move_data[11], @target_battler, @index, @auto_through_flag, []])
    @action_end_cancel = true
    @hit_position = [@real_x, @real_y, self.z]
  end  
  #--------------------------------------------------------------------------
  # ● 到達時間試算
  #--------------------------------------------------------------------------
  def move_calculation(moving_x, moving_y, goal_x, goal_y)
    move_x = @position_x / 100
    move_y = @position_y / 100
    time = 0
    loop do
      move_x += moving_x
      move_y += moving_y
      time += 1
      return time if moving_x < 0 && move_x < goal_x
      return time if moving_x > 0 && move_x > goal_x
      return time if moving_y < 0 && move_y < goal_y
      return time if moving_y > 0 && move_y > goal_y
    end
  end   
  #--------------------------------------------------------------------------
  # ● ミス時に消える処理から貫通処理に変換
  #--------------------------------------------------------------------------
  def through_change
    @action_end_cancel = false
    @through = true
    @move_time = @pre_data[0]
    @target_x = @pre_data[1]
    @target_y = @pre_data[2]
    @pre_data = nil
  end  
  #--------------------------------------------------------------------------
  # ● SE とフラッシュのタイミング処理
  #--------------------------------------------------------------------------
  def animation_process_timing(timing)
    return if !@timing_targets
    se_flag = true
    se_flag = @se_flag if @se_flag != nil
    for target in @timing_targets
      target.sv.timing.push([se_flag, timing.dup])
      se_flag = false if @animation.position == 3
    end  
  end
  #--------------------------------------------------------------------------
  # ● 色調の更新
  #--------------------------------------------------------------------------
  def update_color
    return if @battler.sv.color == []
    self.color.set(@battler.sv.color[0], @battler.sv.color[1], @battler.sv.color[2], @battler.sv.color[3])
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  def dispose
    super
    self.bitmap.dispose if self.bitmap != nil
  end
end 
 
#==============================================================================
# ■ Sprite_Battle_Picture
#------------------------------------------------------------------------------
# 　ピクチャ表示用のスプライトです。
#==============================================================================
class Sprite_Battle_Picture < Sprite
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数　
  #--------------------------------------------------------------------------
  attr_accessor   :action_end           # 終了フラグ
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(viewport = nil)
    super(viewport)
    @action_end = false
    self.ox = 0
  end
  #--------------------------------------------------------------------------
  # ● セット
  #--------------------------------------------------------------------------
  def set(battler)
    @battler = battler
    @data = @battler.sv.effect_data.shift
    @time = @data[4]
    @mirror = $sv_camera.mirror
    @mirror = false if !@data[8]
    self.opacity = @data[6][0]
    @s_x = @data[2][0] if @data[2] != []
    @s_x = Graphics.width - @data[2][0]  if @data[2] != [] && @mirror
    @s_y = @data[2][1] if @data[2] != []
    @e_x = @data[3][0] if @data[3] != []
    @e_x = Graphics.width - @data[3][0] if @data[3] != [] && @mirror
    @e_y = @data[3][1] if @data[3] != []
    @s_x = self.x if @data[2] == []
    @s_y = self.y if @data[2] == []
    @e_x = self.x if @data[3] == []
    @e_y = self.y if @data[3] == []
    self.x = @s_x
    self.y = @s_y
    return @action_end = true if @time == 0
    @move_x = (@e_x * 1.0 - @s_x) / @time
    @move_y = (@e_y * 1.0 - @s_y) / @time
    self.z = @data[5]
    return set_plane(battler) if @data[7] != []
    self.bitmap = Cache.picture(@data[9]) if !bitmap or @data[9] != ""
    return @action_end = true if !bitmap
    self.mirror = @mirror
    self.ox = self.bitmap.width if @mirror
  end
  #--------------------------------------------------------------------------
  # ● プレーン移行
  #--------------------------------------------------------------------------
  def set_plane(battler)
    @viewport = Viewport.new(@data[2][0],@data[2][1],@data[7][0],@data[7][1]) if !@viewport
    viewport = @viewport
    @plane = Plane.new(viewport) if !@plane
    @plane.bitmap = Cache.picture(@data[9]) if !@plane.bitmap or @data[9] != ""
    return @action_end = true if !@plane.bitmap
    @plane.ox = @data[7][0]
    @plane.oy = @data[7][1]
    @plane.opacity = @data[6][0]
    @move_x = @remain_move[0] if @data[2] == @data[3]
    @move_y = @remain_move[1] if @data[2] == @data[3]
    @remain_move = [@move_x, @move_y]
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
    @action_end = true if !@battler.sv.picture
    return if @time == 0
    return if @action_end
    @time -= 1
    return plane_update if @plane
    super
    self.x += @move_x
    self.y += @move_y
    self.opacity += @data[6][1]
    return if @time != 1
    self.x = @e_x
    self.y = @e_y
    @time = 0
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def plane_update
    @plane.ox += @move_x
    @plane.oy += @move_y
    @plane.opacity += @data[6][1]
    @time = @data[4] if @time == 0
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  def dispose
    bitmap.dispose if bitmap
    @plane.dispose if @plane
    @viewport.dispose if @viewport
    super
  end
end
 
#==============================================================================
# ■ Sprite_Back_Picture
#------------------------------------------------------------------------------
# 　周期ピクチャ用のスプライトです。
#==============================================================================
class Sprite_Back_Picture < Plane
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数　
  #--------------------------------------------------------------------------
  attr_accessor   :action_end           # 終了フラグ
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(viewport = nil, index)
    super(viewport)
    @index = index
    @real_x = 0
    @real_y = 0
    @real_opacity = 0
    @move_x = 0
    @move_y = 0
    @move_opacity = 0
    @time = 0
    @switche = 0
    @action_end = false
  end
  #--------------------------------------------------------------------------
  # ● セットアップ
  #--------------------------------------------------------------------------
  def setup(data)
    self.bitmap = Cache.picture(data[9])
    self.z = data[6]
    @switche = data[1]
    mirror = $sv_camera.mirror
    mirror = false if !data[8]
    @move_x = data[3][0]
    @move_x *= -1 if mirror
    @move_y = data[3][1]
    @time = data[4]
    @time = -1 if @time == 0
    @real_opacity = (data[5][0] + 1) * 100
    @move_opacity = data[5][1]
    @start_opacity = data[5][0]
    @shake_ok = data[7]
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
    update_picture if @time != 0
    self.ox = $sv_camera.x - @real_x
    self.oy = $sv_camera.y - @real_y
    if @shake_ok
      self.ox -= $sv_camera.sx / 100
      self.oy -= $sv_camera.sy / 100
    end
    self.ox *= $sv_camera.zoom
    self.oy *= $sv_camera.zoom
    self.zoom_x = @zoom_x * $sv_camera.zoom
    self.zoom_y = @zoom_y * $sv_camera.zoom
    self.opacity = @real_opacity / 100
    @move_opacity *= -1 if self.opacity == 255 or self.opacity <= @start_opacity
    @switche
    @action_end = true if @switche > 0 && !$game_switches[@switche]
    @action_end = true if @switche < 0 && !$sv_camera.switches[@switche.abs]
  end
  #--------------------------------------------------------------------------
  # ● ピクチャの更新
  #--------------------------------------------------------------------------
  def update_picture
    @real_x += @move_x / 100
    @real_y += @move_y / 100
    @real_x = 0 if @real_x >= self.bitmap.width or @real_x <= -self.bitmap.width
    @real_y = 0 if @real_y >= self.bitmap.height or @real_y <= -self.bitmap.height
    @zoom_x = 1
    @zoom_y = 1
    @real_opacity += @move_opacity
    @time -= 1
    @time = -1 if @time < -100
  end
end
 
#==============================================================================
# ■ Sprite_Back_Picture
#------------------------------------------------------------------------------
# 　ダメージ表示のスプライトです。
#==============================================================================
class Sprite_Damage < Sprite
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数　
  #--------------------------------------------------------------------------
  attr_reader   :action_end                  # POP終了フラグ
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(viewport = nil, battler)
    super(viewport)
    @battler = battler
    @time = 0
    return @action_end = true if !@battler
    @direction = -1
    @direction *= -1 if @battler.actor?
    @direction *= -1 if $sv_camera.mirror
    set_state
    set_damage
    update
  end 
  #--------------------------------------------------------------------------
  # ● ステート表示
  #--------------------------------------------------------------------------
  def set_state
    return if !N03::STATE_POP
    states = @battler.result.added_state_objects
    states.delete($data_states[@battler.death_state_id]) if @battler.result.hp_damage != 0
    return if states == []
    return if @battler.sv.add_state == @battler.result.added_state_objects
    @battler.sv.add_state = states.dup
    @st = []
    @st_base = []
    for i in 0...states.size
      @st[i] = Sprite.new
      bitmap_state(@st[i], states[i])
      @st_base[i] = []
      @st_base[i][0] = @direction * (-20 + 5 * i) + @battler.sv.x / 100
      @st_base[i][1] = -40 - @state_height * i + (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.oy_adjust)/ 100
      @st[i].z = 1000 + i
      @st[i].opacity = 0
    end
    @time = @pop_time = 80
  end   
  #--------------------------------------------------------------------------
  # ● ステート画像
  #--------------------------------------------------------------------------
  def bitmap_state(state, state_object)
    name = state_object.name
    state.bitmap = Cache.system("Iconset").dup
    state.src_rect.set(state_object.icon_index % 16 * 24, state_object.icon_index / 16 * 24, 24, 24)
    @state_height = 24
  end
  #--------------------------------------------------------------------------
  # ● ダメージ表示
  #--------------------------------------------------------------------------
  def hit_count
    for i in 0...@battler.sv.hit.size
      if @battler.sv.hit[i] == nil
        @hit = i
        return @battler.sv.hit[i] = @hit
      end
    end
    @hit = @battler.sv.hit.size
    @battler.sv.hit.push(@hit)
  end  
  #--------------------------------------------------------------------------
  # ● ダメージ表示
  #--------------------------------------------------------------------------
  def set_damage
    return @action_end = true if !N03::DAMAGE_POP
    damage = @battler.result.hp_damage if @battler.result.hp_damage != 0
    damage = @battler.result.hp_drain  if @battler.result.hp_drain  != 0
    damage = @battler.result.mp_damage if @battler.result.mp_damage != 0
    damage = @battler.result.mp_drain  if @battler.result.mp_drain  != 0
    damage = @battler.result.tp_damage if @battler.result.tp_damage != 0
    if !damage or damage == 0
      @action_end = true if @st == nil
      return # ステートだけPOPする設定を考慮して@action_endは返さない
    end
    hit_count
    #@hit = @battler.sv.hit
    #@battler.sv.hit += 1 if damage != 0
    file = N03::DAMAGE_PLUS if damage > 0
    file = N03::DAMAGE_MINUS if damage < 0
    add_file = N03::DAMAGE_MP if @battler.result.mp_damage != 0
    add_file = N03::DAMAGE_TP if @battler.result.tp_damage != 0
    adjust_x = N03::DAMAGE_ADJUST
    @num = []
    @num_base = []
    damage = damage.abs
    max_num = damage.to_s.size
    max_num += 1 if add_file != nil
    for i in 0...max_num
      @num[i] = Sprite.new
      if add_file != nil && i == max_num - 1
        @num[i].bitmap = Cache.system(add_file)
        cw = (damage % (10 * 10 ** i))/(10 ** i)
        sw = 0 if sw == nil
      else
        @num[i].bitmap = Cache.system(file)
        cw = (damage % (10 * 10 ** i))/(10 ** i)
        sw = @num[i].bitmap.width / 10
        @num[i].src_rect.set(cw * sw, 0, sw, @num[i].bitmap.height)
      end
      @num_base[i] = []
      @num_base[i][0] = (sw + adjust_x) * i * -1 + (@battler.sv.x / 100)
      @num_base[i][1] =  -(@num[i].bitmap.height * 5) - i * 1 - @hit * 2 + (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.oy_adjust)/ 100
      @num_base[i][0] -= @num[i].bitmap.width / 2 - adjust_x if add_file != nil && i == max_num - 1
      @num[i].z = 1000 + i + @hit * 10
    end
    @time = @pop_time = 80
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
    return if @time == 0
    for i in 0...@st.size do update_state_move(@st[i], i) end if @st != nil
    for i in 0...@num.size do update_num_move(@num[i], i) end if @num != nil
    @time -= 1
    @action_end = true if @time == 0
  end
  #--------------------------------------------------------------------------
  # ● ステート画像の更新
  #--------------------------------------------------------------------------
  def update_state_move(state, index)
    min = @pop_time - index * 2
    case @time
    when min-15..min
      @st_base[index][0] += @direction
      state.opacity += 25
    when min-80..min-50
      @st_base[index][0] += @direction
      state.opacity -= 25
    end
    state.x = (@st_base[index][0] - $sv_camera.x) * $sv_camera.zoom
    state.y = (@st_base[index][1] - $sv_camera.y) * $sv_camera.zoom
  end
  #--------------------------------------------------------------------------
  # ● 数値の更新
  #--------------------------------------------------------------------------
  def update_num_move(num, index)
    min = @pop_time - index * 2
    case @time
    when min-1..min
      @num_base[index][0] += @direction * @hit
      @num_base[index][1] -= 5 + @hit * 2
    when min-3..min-2
      @num_base[index][0] += @direction * @hit
      @num_base[index][1] -= 4 + @hit * 2
    when min-6..min-4
      @num_base[index][0] += @direction
      @num_base[index][1] -= 3 + @hit * 2
    when min-14..min-7
      @num_base[index][0] += @direction
      @num_base[index][1] += 2
    when min-17..min-15
      @num_base[index][1] -= 2 + @hit * 2
    when min-23..min-18
      @num_base[index][1] += 1
    when min-27..min-24
      @num_base[index][1] -= 1
    when min-30..min-28
      @num_base[index][1] += 1
    when min-33..min-31
      @num_base[index][1] -= 1
    when min-36..min-34
      @num_base[index][1] += 1
    end
    num.x = (@num_base[index][0] - $sv_camera.x) * $sv_camera.zoom
    num.y = (@num_base[index][1] - $sv_camera.y) * $sv_camera.zoom
    num.opacity = 256 - (12 - @time) * 32
    num.visible = false if @time == 0
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  def dispose
    @battler.sv.hit[@hit] = nil if @hit
    bitmap.dispose if bitmap
    for i in 0...@num.size do @num[i].dispose end if @num != nil
    for i in 0...@st.size do @st[i].dispose end if @st != nil
    super
  end
end
 
#==============================================================================
# ■ Window_Skill_name
#------------------------------------------------------------------------------
# 　スキル名を表示するウィンドウです。
#==============================================================================
class Window_Skill_name < Window_Base
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(text)
    super(0, 0, Graphics.width, line_height + standard_padding * 2)
    draw_text(4, 0, Graphics.width - 64, line_height,text, 1)
  end
end
 
#==============================================================================
# ■ Spriteset_Sideview
#------------------------------------------------------------------------------
# 　サイドビュー独自のスプライトをまとめたクラスです。
#==============================================================================
class Spriteset_Sideview
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(viewport)
    @viewport = viewport
    @weapons = []
    @pictures = []
    @back_pic = []
    @damage = []
    $sv_camera.setup
    N03.camera(nil, N03::BATTLE_CAMERA["ターン開始前"].dup)
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
    update_battler_data
    update_damage
    update_pictures
    update_back_pic
    update_weapons
  end  
  #--------------------------------------------------------------------------
  # ● バトラーデータの更新
  #--------------------------------------------------------------------------
  def update_battler_data
    for battler in $game_party.battle_members + $game_troop.members
      weapon_end(battler) if battler.sv.weapon_end
      next if battler.sv.effect_data == []
      for effect_data in battler.sv.effect_data do set_effects(battler, effect_data) end
    end
  end
  #--------------------------------------------------------------------------
  # ● ダメージ画像の更新
  #--------------------------------------------------------------------------
  def update_damage
    for i in 0...@damage.size
      next if @damage[i] == nil
      @damage[i].update if @damage[i] != nil
      next if !@damage[i].action_end
      @damage[i].dispose
      @damage[i] = nil
    end
  end
  #--------------------------------------------------------------------------
  # ● ピクチャアクションの更新
  #--------------------------------------------------------------------------
  def update_pictures
    for i in 0...@pictures.size
      next if @pictures[i] == nil
      @pictures[i].update if @pictures[i] != nil
      next if !@pictures[i].action_end
      @pictures[i].dispose
      @pictures[i] = nil
    end
  end
  #--------------------------------------------------------------------------
  # ● 周期ピクチャの更新
  #--------------------------------------------------------------------------
  def update_back_pic
    set_back_pic if $sv_camera.program_picture != []
    for i in 0...@back_pic.size
      next if @back_pic[i] == nil
      @back_pic[i].update if @back_pic[i] != nil
      next if !@back_pic[i].action_end
      @back_pic[i].dispose
      @back_pic[i] = nil
    end
  end
  #--------------------------------------------------------------------------
  # ● 武器アクションの更新
  #--------------------------------------------------------------------------
  def update_weapons
    for i in 0...@weapons.size
      next if @weapons[i] == nil
      @weapons[i].update if @weapons[i] != nil
      next if !@weapons[i].action_end
      @weapons[i].dispose
      @weapons[i] = nil
    end
  end
  #--------------------------------------------------------------------------
  # ● ダメージ実行
  #--------------------------------------------------------------------------
  def set_damage_pop(target)
    for i in 0...@damage.size
      next if @damage[i] != nil
      return @damage[i] = Sprite_Damage.new(@viewport, target)
    end
    @damage.push(Sprite_Damage.new(@viewport, target))
  end
  #--------------------------------------------------------------------------
  # ● 周期ピクチャ実行
  #--------------------------------------------------------------------------
  def set_back_pic
    for data in $sv_camera.program_picture
      if @back_pic[data[2]] != nil
        @back_pic[data[2]].dispose
        @back_pic[data[2]] = nil
      end
      @back_pic[data[2]] = Sprite_Back_Picture.new(@viewport, data[2])
      @back_pic[data[2]].setup(data)
    end
    $sv_camera.program_picture = []
  end
  #--------------------------------------------------------------------------
  # ● エフェクト開始
  #--------------------------------------------------------------------------
  def set_effects(battler, effect_data)
    case effect_data[0]
    when "pic" ; set_pictures(battler, effect_data)
    when  "wp" ; set_weapons(battler,  true)
    when "m_a" ; set_weapons(battler, false)
    end
  end
  #--------------------------------------------------------------------------
  # ● ピクチャアクション実行
  #--------------------------------------------------------------------------
  def set_pictures(battler, effect_data)
    @pictures[effect_data[1]] = Sprite_Battle_Picture.new if @pictures[effect_data[1]] == nil
    @pictures[effect_data[1]].set(battler)
  end
  #--------------------------------------------------------------------------
  # ● 武器アクション実行
  #--------------------------------------------------------------------------
  def set_weapons(battler, weapon_flag, test = true)
    for i in 0...@weapons.size
      next if @weapons[i] != nil
      @weapons[i] = Sprite_Weapon.new(@viewport, i, battler) 
      battler.sv.weapon_index.push(i) if weapon_flag
      return i
    end
    @weapons.push(Sprite_Weapon.new(@viewport, @weapons.size, battler))
    battler.sv.weapon_index.push(@weapons.size - 1) if weapon_flag
    return @weapons.size - 1
  end
  #--------------------------------------------------------------------------
  # ● バトラーの武器アクション終了
  #--------------------------------------------------------------------------
  def weapon_end(battler)
    battler.sv.weapon_end = false
    for index in battler.sv.weapon_index
      weapon_index = battler.sv.weapon_index.shift
      @weapons[weapon_index].dispose if @weapons[weapon_index] != nil
      @weapons[weapon_index] = nil
    end
    battler.sv.weapon_index.compact!
  end  
  #--------------------------------------------------------------------------
  # ● ヒット時の戦闘アニメ実行
  #--------------------------------------------------------------------------
  def set_hit_animation(battler, weapon_index, hit_targets, miss)
    weapon = @weapons[weapon_index]
    for target in hit_targets
      next @weapons[@hit_index].timing_battler_set(target) if @hit_index != nil
      @hit_index = set_weapons(battler, false, false)
      @weapons[@hit_index].set_hit_animation(weapon.hit_position, weapon.hit_anime_id, target)
    end
    @hit_index = nil
    if !weapon.through && !miss
      @weapons[weapon_index].dispose
      @weapons[weapon_index] = nil
    else
      @weapons[weapon_index].through_change
    end
  end
  #--------------------------------------------------------------------------
  # ● サイドビューデータの初期化
  #--------------------------------------------------------------------------
  def reset_sideview
    $sv_camera.reset
    for member in $game_troop.members + $game_party.battle_members do member.sv.reset end
  end  
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  def dispose
    dispose_effects(@weapons)
    dispose_effects(@pictures)
    dispose_effects(@back_pic)
    dispose_effects(@damage)
    reset_sideview
  end
  #--------------------------------------------------------------------------
  # ● エフェクト画像の解放
  #--------------------------------------------------------------------------
  def dispose_effects(effects)
    for i in 0...effects.size
      effects[i].dispose if effects[i] != nil
      effects[i] = nil
    end
  end
end
 
 
#==============================================================================
# ■ Sprite_Battle_Back
#------------------------------------------------------------------------------
# 　戦闘背景用のスプライトです。
#==============================================================================
class Sprite_Battle_Back < Plane
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(viewport = nil, index, battleback_name)
    super(viewport)
    @index = index
    if @index == 1
      data = N03::FLOOR1_DATA[battleback_name]
      data = N03::FLOOR1_DATA["全Battlebacks1"] if data == nil
    elsif @index == 2
      data = N03::FLOOR2_DATA[battleback_name]
      data = N03::FLOOR2_DATA["全Battlebacks2"] if data == nil
    end    
    data = data.dup
    @adjust_position = data[0]
    @zoom_x = data[1][0] / 100.0
    @zoom_y = data[1][1] / 100.0
    @shake_on = data[2]
    $game_switches[data[3]] = true if data[3] > 0
    $sv_camera.switches[data[3].abs] = true if data[3] < 0
    reset_scroll
    reset_back_data(battleback_name)
  end
  #--------------------------------------------------------------------------
  # ● 背景スクロールを初期化
  #--------------------------------------------------------------------------
  def reset_scroll
    @scroll_x = 0
    @scroll_y = 0
    @move_x = 0
    @move_y = 0
  end
  #--------------------------------------------------------------------------
  # ● 背景データを初期化
  #--------------------------------------------------------------------------
  def reset_back_data(battleback_name)
    @back_data = []
    @active_data = ["scroll",0, @move_x, @move_y, false, battleback_name,""]
    start_back_data(@active_data)
  end  
  #--------------------------------------------------------------------------
  # ● 背景画像のセッティング
  #--------------------------------------------------------------------------
  def set_graphics(new_bitmap)
    self.bitmap = new_bitmap
    @base_x = (self.bitmap.width * @zoom_x - Graphics.width) / 2 + @adjust_position[0]
    @base_y = (self.bitmap.height * @zoom_y - Graphics.height) / 2 + @adjust_position[1]
    # 限界座標を取得
    max_top =  0
    max_bottom = self.bitmap.height * @zoom_y - Graphics.height
    max_left = 0
    max_right = self.bitmap.width * @zoom_x - Graphics.width
    exist = true 
    exist = false if self.bitmap.height == 32 && self.bitmap.width == 32
    $sv_camera.setting(@index, [max_top, max_bottom, max_left, max_right, @base_x, @base_y,exist])
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
    return if !bitmap
    update_back_data
    update_scroll unless @move_x == 0 && @move_y == 0
    update_color
    update_position
    update_back_adjust if @bt_back != nil
    create_back_adjust if @bt_back == nil && !@active_data[10] && @scroll_x == 0 && @scroll_y == 0
  end
  #--------------------------------------------------------------------------
  # ● 背景データを更新
  #--------------------------------------------------------------------------
  def update_back_data
    delete = true if @active_data[1] > 0 && !$game_switches[@active_data[1]]
    delete = true if @active_data[1] < 0 && !$sv_camera.switches[@active_data[1].abs]
    return if !delete
    for i in 0...@back_data.size
      @back_data[i] = nil if @back_data[i][1] > 0 && !$game_switches[@back_data[i][1]]
      @back_data[i] = nil if @back_data[i][1] < 0 && !$sv_camera.switches[@back_data[i][1].abs]
    end
    @back_data.compact!
    next_back_data
  end
  #--------------------------------------------------------------------------
  # ● 次の背景データをセット
  #--------------------------------------------------------------------------
  def next_back_data
    @back_data.delete(@active_data[11]) if @active_data[11] != nil
    @back_data.push(@active_data[11]) if @active_data[11] != nil
    @active_data = nil
    data = @back_data.pop
    @back_data = [@active_data] if @back_data.size == 0
    start_back_data(data)
  end  
  #--------------------------------------------------------------------------
  # ● 背景データを実行
  #--------------------------------------------------------------------------
  def start_back_data(data)
    return if back_data_remain(data)
    bt_back_dispose
    pre_active_data = @active_data
    @active_data[8] = [@back_name, @move_x, @move_y, @scroll_x, @scroll_y] if @active_data != nil
    @back_data.push(@active_data)     if @active_data != nil
    @active_data = data.dup
    @active_data[5] = @back_name      if @active_data[5] == ""
    @active_data[9] = set_back_adjust if @active_data[9] == nil
    back_data_scroll_on               if @active_data[8] == nil && @active_data[9][0] == false
    set_remain_back_data              if @active_data[8] != nil
    create_back(@active_data[5])      if @active_data[9][0] == false
    create_back_adjust                if @active_data[10]
    @active_data[11] = pre_active_data if pre_active_data && @active_data[7] == false
  end  
  #--------------------------------------------------------------------------
  # ● 背景データの保留
  #--------------------------------------------------------------------------
  def back_data_remain(data)
    remain = false
    remain = true if data[6] != "" && @active_data != nil && @active_data[9] != nil && @active_data[9][0] != false
    remain = true if @active_data != nil && @active_data[7] == false
    return remain if !remain
    @remain = true
    @back_data.push(data)
    return remain
  end  
  #--------------------------------------------------------------------------
  # ● 背景変更補正データをセット
  #--------------------------------------------------------------------------
  def set_back_adjust
    bt_adjust = []
    sign = -1
    if @active_data[6] == ""
      reset_scroll if @active_data[3][0] == 0 &&  @active_data[3][1] == 0
      bt_adjust = [false,false,0,0]
      return bt_adjust
    elsif @move_x != 0 or @active_data[3][0] != 0
      sign = 1 if @move_x < 0
      bt_adjust[0] = [self.bitmap.width * @zoom_x * sign, 0]
      bt_adjust[1] = [self.bitmap.width * @zoom_x * sign * 2, 0]
    elsif @move_y != 0 or @active_data[3][1] != 0
      sign = 1 if @move_y < 0
      bt_adjust[0] = [0, self.bitmap.height * @zoom_y * sign]
      bt_adjust[1] = [0, self.bitmap.height * @zoom_y * sign * 2]
    else
      reset_scroll if @active_data[3][0] == 0 &&  @active_data[3][1] == 0
      bt_adjust = [false,false,0,0]
      return bt_adjust
    end
    bt_adjust[2] = [bt_adjust[0][0], bt_adjust[0][1]]
    return bt_adjust
  end
  #--------------------------------------------------------------------------
  # ● 背景スクロールデータを実行
  #--------------------------------------------------------------------------
  def back_data_scroll_on
    mirror = $sv_camera.mirror
    mirror = false if !@active_data[4]
    @move_x = @active_data[3][0]
    @move_x *= -1 if mirror
    @move_y = @active_data[3][1]
  end
  #--------------------------------------------------------------------------
  # ● 保持している背景データを実行
  #--------------------------------------------------------------------------
  def set_remain_back_data
    return back_data_scroll_on if @move_x != 0 or @move_y != 0
    create_back(@active_data[8][0])
    @move_x    = @active_data[8][1]
    @move_y    = @active_data[8][2]
    @scroll_x  = @active_data[8][3]
    @scroll_y  = @active_data[8][4]
  end  
  #--------------------------------------------------------------------------
  # ● 背景画像の作成
  #--------------------------------------------------------------------------
  def create_back(back_name)
    return if back_name == @back_name or back_name == ""
    self.bitmap = Cache.battleback1(back_name) if @index == 1
    self.bitmap = Cache.battleback2(back_name) if @index == 2
    @back_name = back_name
  end  
  #--------------------------------------------------------------------------
  # ● 背景変更補正画像の作成
  #--------------------------------------------------------------------------
  def create_back_adjust
    return if @active_data[9][0] == false
    @active_data[10] = true
    mirror = $sv_camera.mirror
    mirror = false if !@active_data[4]
    @bt_back = []
    @bt_back[0] = Sprite.new(viewport)
    @bt_back[0].bitmap = Cache.battleback1(@active_data[6]) if @index == 1
    @bt_back[0].bitmap = Cache.battleback2(@active_data[6]) if @index == 2
    @bt_back[0].mirror = mirror
    @bt_back[1] = Sprite.new(viewport)
    @bt_back[1].bitmap = Cache.battleback1(@active_data[5]) if @index == 1
    @bt_back[1].bitmap = Cache.battleback2(@active_data[5]) if @index == 2
    @bt_back[1].mirror = mirror
  end
  #--------------------------------------------------------------------------
  # ● 背景スクロールの更新
  #--------------------------------------------------------------------------
  def update_scroll
    @scroll_x += @move_x
    @scroll_y += @move_y
    @scroll_x = 0 if @scroll_x / 100 >= self.bitmap.width * @zoom_x or @scroll_x / 100 <= -self.bitmap.width * @zoom_x
    @scroll_y = 0 if @scroll_y / 100 >= self.bitmap.height * @zoom_y or @scroll_y / 100 <= -self.bitmap.height * @zoom_y
  end
  #--------------------------------------------------------------------------
  # ● 色調変更の更新
  #--------------------------------------------------------------------------
  def update_color
    color_set if $sv_camera.color_set[@index] != nil
    return if @color_data == nil
    @color_data[4] -= 1
    if @color_data[4] == 0 && @color_data[5] != 0
      @color_data[4] = @color_data[5]
      @color_data[5] = 0
      @color_data[6] = [0,0,0,0]
    elsif @color_data[4] == 0
      @remain_color_data = @color_data
      return @color_data = nil
    end  
    for i in 0..3
      @color_data[i] = (@color_data[i] * (@color_data[4] - 1) + @color_data[6][i]) / @color_data[4]
    end  
    self.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3])
  end
  #--------------------------------------------------------------------------
  # ● 座標の更新
  #--------------------------------------------------------------------------
  def update_position
    self.ox = $sv_camera.x + @base_x - @scroll_x / 100
    self.oy = $sv_camera.y + @base_y - @scroll_y / 100
    self.ox -= $sv_camera.sx / 100 if @shake_on
    self.oy -= $sv_camera.sy / 100 if @shake_on
    self.zoom_x = @zoom_x * $sv_camera.zoom
    self.zoom_y = @zoom_y * $sv_camera.zoom
    self.ox *= $sv_camera.zoom
    self.oy *= $sv_camera.zoom
    self.z = @index * 10
  end
  #--------------------------------------------------------------------------
  # ● 背景変更補正画像を更新
  #--------------------------------------------------------------------------
  def update_back_adjust
    @active_data[9][0][0] = 0 if @scroll_x == 0
    @active_data[9][0][1] = 0 if @scroll_y == 0
    @active_data[9][1][0] -= @active_data[9][2][0] if @scroll_x == 0
    @active_data[9][1][1] -= @active_data[9][2][1] if @scroll_y == 0
    for i in 0...@bt_back.size
      @bt_back[i].x = -self.ox + @active_data[9][i][0] * $sv_camera.zoom
      @bt_back[i].y = -self.oy + @active_data[9][i][1] * $sv_camera.zoom
      @bt_back[i].zoom_x = self.zoom_x
      @bt_back[i].zoom_y = self.zoom_y
      @bt_back[i].z = self.z + 1
      @bt_back[i].color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
    end
    back_data_scroll_on if @active_data[9][0][0] == 0 && @active_data[9][0][1] == 0
    return unless @active_data[9][1][0] == 0 && @active_data[9][1][1] == 0
    bt_back_dispose
    create_back(@active_data[5])
    @active_data[9][0] = false
    next_back_data if @remain && @back_data.size != 1
    @remain = false
  end
  #--------------------------------------------------------------------------
  # ● 色調変更
  #--------------------------------------------------------------------------
  def color_set
    set = $sv_camera.color_set[@index]
    $sv_camera.color_set[@index] = nil
    set[4] = 1 if set[4] == 0
    @remain_color_data = [0,0,0,0] if @remain_color_data == nil
    @color_data = @remain_color_data
    @color_data[4] = set[4]
    @color_data[5] = set[5]
    @color_data[6] = set
  end
  #--------------------------------------------------------------------------
  # ● 背景変更補正画像の解放
  #--------------------------------------------------------------------------
  def bt_back_dispose
    for i in 0...@bt_back.size do @bt_back[i].dispose end if @bt_back != nil
    @bt_back = nil
  end  
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  def dispose
    bitmap.dispose if bitmap
    bt_back_dispose
    super
  end
end  
 
#==============================================================================
# ■ Battle_Camera
#------------------------------------------------------------------------------
# 　戦闘カメラやバトルプログラムを扱うクラスです。 
#==============================================================================
class Battle_Camera
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数　
  #--------------------------------------------------------------------------
  attr_reader   :sx                 # シェイクX座標
  attr_reader   :sy                 # シェイクY座標
  attr_reader   :max_top            # 上限界座標
  attr_reader   :max_bottom         # 下限界座標
  attr_reader   :max_left           # 左限界座標
  attr_reader   :max_right          # 右限界座標
  attr_accessor :switches           # サイドビュー専用スイッチ
  attr_accessor :color_set          # 色調変更データ
  attr_accessor :wait               # 戦闘シーンの強制ウエイト
  attr_accessor :win_wait           # 戦闘勝利前のウエイト
  attr_accessor :mirror             # 画面反転フラグ
  attr_accessor :program_scroll     # バトルプログラム 背景の自動スクロール
  attr_accessor :program_picture    # バトルプログラム 周期ピクチャ
  attr_accessor :event              # コモンイベント呼び出し
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化 
  #--------------------------------------------------------------------------
  def initialize
    @switches = []
    @max_data = []
    @color_set = []
    @wait = 0
    @win_wait = false
    @mirror = false
    @event = false
    setup
  end
  #--------------------------------------------------------------------------
  # ● カメラX座標
  #--------------------------------------------------------------------------
  def x
    return @x / 100
  end
  #--------------------------------------------------------------------------
  # ● カメラY座標
  #--------------------------------------------------------------------------
  def y
    return @y / 100
  end
  #--------------------------------------------------------------------------
  # ● ズーム率 
  #--------------------------------------------------------------------------
  def zoom
    return @zoom * 0.001
  end
  #--------------------------------------------------------------------------
  # ● ズーム率による座標変換
  #--------------------------------------------------------------------------
  def convert
    return @zoom
  end
  #--------------------------------------------------------------------------
  # ● カメラセットアップ
  #--------------------------------------------------------------------------
  def setup
    @x = 0
    @y = 0
    @sx = 0
    @sy = 0
    @zoom = 1000
    @time = 0
    @shake_time = 0
    program_setup
  end
  #--------------------------------------------------------------------------
  # ● カメラ初期化
  #--------------------------------------------------------------------------
  def reset
    @switches = []
    @max_data = []
    @color_set = []
    @wait = 0
    @win_wait = false
    @mirror = false
    program_setup(false)
  end  
  #--------------------------------------------------------------------------
  # ● バトルプログラムのセットアップ
  #--------------------------------------------------------------------------
  def program_setup(check = true)
    @played_program  = []
    @program_switch  = []
    @program_sound   = []
    @program_scroll  = []
    @program_se      = []
    @program_shake   = []
    @program_color   = []
    @program_picture = []
    @program_base = N03::BATTLE_PROGRAM.values.dup
    program_check if check
  end  
  #--------------------------------------------------------------------------
  # ● バトルプログラムのチェック
  #--------------------------------------------------------------------------
  def program_check
    for data in @program_base
      if program_start?(data) && !@played_program.include?(data)
        @played_program.push(data.dup)
        @program_scroll.push(data.dup)  if data[0] == "scroll"
        @program_picture.push(data.dup) if data[0] == "kpic"
        start_sound(data.dup)           if data[0] == "sound"
        start_program_switch(data.dup)  if data[0] == "switch"
        start_program_se(data.dup)      if data[0] == "keep_se"
        start_program_shake(data.dup)   if data[0] == "keep_sk"
        start_program_color(data.dup)   if data[0] == "keep_c"
      else
        @played_program.delete(data)  if !program_start?(data)
        @program_scroll.delete(data)  if data[0] == "scroll"
        @program_picture.delete(data) if data[0] == "kpic"
        @program_switch.delete(data)  if data[0] == "switch"
        @program_sound.delete(data)   if data[0] == "sound"
        @program_se.delete(data)      if data[0] == "keep_se"
        @program_shake.delete(data)   if data[0] == "keep_sk"
        @program_color.delete(data)   if data[0] == "keep_c"
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● バトルプログラムの開始
  #--------------------------------------------------------------------------
  def program_start?(data)
    start = false
    start = true if $game_switches[data[1].abs] && data[1] > 0
    start = true if @switches[data[1].abs] && data[1] < 0
    return start
  end  
  #--------------------------------------------------------------------------
  # ● バトルプログラム スイッチ操作の開始
  #--------------------------------------------------------------------------
  def start_program_switch(data)
    data[4] = data[4] + rand(data[5] + 1)
    data[4] = 1 if data[4] <= 0
    @program_switch.push(data)
  end
  #--------------------------------------------------------------------------
  # ● スイッチ操作の更新
  #--------------------------------------------------------------------------
  def update_program_switch
    for data in @program_switch
      data[4] -= 1
      next @program_switch.delete(data) if data[1] > 0 && !$game_switches[data[1]]
      next @program_switch.delete(data) if data[1] < 0 && !@switches[data[1].abs]
      next if data[4] != 0
      for id in data[2]
        $game_switches[id] = true if id > 0
        @switches[id.abs] = true  if id < 0
      end
      for id in data[3]
        $game_switches[id] = false if id > 0
        @switches[id.abs] = false  if id < 0
      end
      @program_switch.delete(data)
      program_check
    end  
  end
  #--------------------------------------------------------------------------
  # ● バトルプログラム BGM/BGSの開始
  #--------------------------------------------------------------------------
  def start_sound(data)
    @program_sound.push(data)
    name = data[5]
    case data[2]
    when "se"
      Audio.se_play("Audio/SE/" + name, data[4], data[3])
    when "bgm"
      name = RPG::BGM.last.name if data[5] == ""
      Audio.bgm_play("Audio/BGM/" + name, data[4], data[3])
    when "bgs"
      name = RPG::BGS.last.name if data[5] == ""
      Audio.bgs_play("Audio/BGS/" + name, data[4], data[3])
    end
  end
  #--------------------------------------------------------------------------
  # ● バトルプログラム 周期SEの開始
  #--------------------------------------------------------------------------
  def start_program_se(data)
    data[3] = [data[2], data[3]]
    data[2] = data[3][0] + rand(data[3][1] + 1)
    @program_se.push(data)
    Audio.se_play("Audio/SE/" + data[7], data[5], data[4]) if data[6]
  end
  #--------------------------------------------------------------------------
  # ● 周期SEの更新
  #--------------------------------------------------------------------------
  def update_program_se
    for data in @program_se
      data[2] -= 1
      next @program_se.delete(data) if data[1] > 0 && !$game_switches[data[1]]
      next @program_se.delete(data) if data[1] < 0 && !@switches[data[1].abs]
      next if data[2] != 0
      Audio.se_play("Audio/SE/" + data[7], data[5], data[4])
      data[2] = data[3][0] + rand(data[3][1] + 1)
    end  
  end
  #--------------------------------------------------------------------------
  # ● バトルプログラム 周期シェイクの開始
  #--------------------------------------------------------------------------
  def start_program_shake(data)
    data[3] = [data[2], data[3]]
    data[2] = data[3][0] + rand(data[3][1] + 1)
    @program_shake.push(data)
    shake(data[4], data[5], data[6]) if data[7]
  end
  #--------------------------------------------------------------------------
  # ● 周期シェイクの更新
  #--------------------------------------------------------------------------
  def update_program_shake
    for data in @program_shake
      data[2] -= 1
      next @program_shake.delete(data) if data[1] > 0 && !$game_switches[data[1]]
      next @program_shake.delete(data) if data[1] < 0 && !@switches[data[1].abs]
      next if data[2] != 0
      shake(data[4], data[5], data[6])
      data[2] = data[3][0] + rand(data[3][1] + 1)
    end  
  end
  #--------------------------------------------------------------------------
  # ● バトルプログラム 周期色調変更の開始
  #--------------------------------------------------------------------------
  def start_program_color(data)
    data[3] = [data[2], data[3]]
    data[2] = data[3][0] + rand(data[3][1] + 1)
    data[7] = true if data[4] == 0 or data[4] == 4
    case data[4]
    when 1   ;data[4] = $game_troop.members
    when 2   ;data[4] = $game_party.battle_members
    when 3,4 ;data[4] = $game_troop.members + $game_party.battle_members
    else ;data[4] = []
    end
    @program_color.push(data)
    return if !data[6]
    for target in data[4] do target.sv.color_set = data[5] end if data[4] != []
    @color_set[1] = data[5] if data[7]
    @color_set[2] = data[5] if data[7]
  end
  #--------------------------------------------------------------------------
  # ● 周期色調変更の更新
  #--------------------------------------------------------------------------
  def update_program_color
    for data in @program_color
      data[2] -= 1
      next @program_color.delete(data) if data[1] > 0 && !$game_switches[data[1]]
      next @program_color.delete(data) if data[1] < 0 && !@switches[data[1].abs]
      next if data[2] != 0
      for target in data[4] do target.sv.color_set = data[5] end if data[4] != []
      @color_set[1] = data[5] if data[7]
      @color_set[2] = data[5] if data[7]
      data[2] = data[3][0] + rand(data[3][1] + 1)
    end 
  end
  #--------------------------------------------------------------------------
  # ● トランジション実行
  #--------------------------------------------------------------------------
  def perform_transition(data)
    Graphics.transition(data[2], "Graphics/Pictures/" + data[3], data[1])
  end  
  #--------------------------------------------------------------------------
  # ● 背景からカメラの限界値を取得  data = [max_top, max_bottom, max_left, max_right]
  #--------------------------------------------------------------------------
  def setting(index, data)
    @max_data[index - 1] = data
    return if index != 2
    setup
    # カメラの中心座標
    @center_x     = (Graphics.width / 2 + N03::CAMERA_POSITION[0]) * 100
    @center_y     = (Graphics.height / 2 + N03::CAMERA_POSITION[1]) * 100
    # 上下左右の移動限界距離
    @max_top    = [@max_data[0][5], @max_data[1][5]].min * -1
    @max_bottom = [@max_data[0][1], @max_data[1][1]].min + @max_top
    @max_left   = [@max_data[0][4], @max_data[1][4]].min  * -1
    @max_right  = [@max_data[0][3], @max_data[1][3]].min + @max_left
    exist_data = @max_data[0] if !@max_data[1][6]
    exist_data = @max_data[1] if !@max_data[0][6]
    @max_top    = exist_data[5] * -1        if exist_data != nil
    @max_bottom = exist_data[1] + @max_top  if exist_data != nil
    @max_left   = exist_data[4] * -1        if exist_data != nil
    @max_right  = exist_data[3] + @max_left if exist_data != nil
    @max_top = @max_bottom = @max_left = @max_right = 0 if !@max_data[1][6] && !@max_data[0][6]
    @max_width    = @max_right - @max_left + Graphics.width
    @max_height   = @max_bottom - @max_top + Graphics.height
    # ズームアウト限界値
    max_zoom_x    = 100 * Graphics.width / @max_width
    max_zoom_y    = 100 * Graphics.height / @max_height
    @max_zoom_out = [max_zoom_x, max_zoom_y].max
  end
  #--------------------------------------------------------------------------
  # ● カメラ移動
  #--------------------------------------------------------------------------
  def move(target_x, target_y, zoom, time, screen = true)
    # 戦闘背景以上のサイズまでズームアウトしないよう調整
    @target_zoom = [zoom * 0.01, @max_zoom_out * 0.01].max
    target_x *= -1 if screen && @mirror
    # ズーム分の中心座標補正
    if screen && @target_zoom != 1
      target_x = target_x + @center_x
      target_y = target_y + @center_y
    end
    adjust_x = @center_x * (@target_zoom - 1) / (@target_zoom ** 2 - @target_zoom)
    adjust_y = @center_y * (@target_zoom - 1) / (@target_zoom ** 2 - @target_zoom)
    adjust_x = 0 if adjust_x.nan?
    adjust_y = 0 if adjust_y.nan?
    adjust_x = @center_x if !screen && adjust_x == 0
    adjust_y = @center_y if !screen && adjust_y == 0
    @target_x = target_x - adjust_x.to_i
    @target_y = target_y - adjust_y.to_i
    @target_zoom = (@target_zoom * 1000).to_i
    @zoom = @zoom.to_i
    limit_test
    # 時間0の場合は即実行
    return @time = time.abs if time != 0
    @time = 1
    update
  end
  #--------------------------------------------------------------------------
  # ● 限界座標の試算
  #--------------------------------------------------------------------------
  def limit_test
    new_width = @max_width * @target_zoom / 1000
    new_height = @max_height * @target_zoom / 1000
    new_max_right = @max_right - (@max_width - new_width)
    new_max_bottom = @max_bottom - (@max_height - new_height)
    # 画面の移動先が限界の場合、限界座標をセット
    if @target_x < @max_left * 100
      @target_x = @max_left * 100
    end 
    if @target_x > new_max_right * 100
      @target_x = new_max_right * 100
    end
    if @target_y < @max_top * 100
      @target_y = @max_top * 100
    end
    if @target_y > new_max_bottom * 100
      @target_y = new_max_bottom * 100
    end
  end
  #--------------------------------------------------------------------------
  # ● 画面のシェイク
  #--------------------------------------------------------------------------
  def shake(power, speed, time)
    @shake_x = power[0] * 100
    @shake_y = power[1] * 100
    @power_time_base = @power_time = speed
    @shake_time = time
    update_shake
  end
  #--------------------------------------------------------------------------
  # ● シェイクの更新
  #--------------------------------------------------------------------------
  def update_shake
    @sx = (@sx * (@power_time - 1) + @shake_x) / @power_time
    @sy = (@sy * (@power_time - 1) + @shake_y) / @power_time
    @power_time -= 1
    @shake_time -= 1
    return @sx = @sy = 0 if @shake_time == 0
    return if @power_time != 0
    @power_time = @power_time_base
    @shake_x = @shake_x * -4 / 5
    @shake_y = @shake_y * -4 / 5
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
    update_shake if @shake_time != 0
    update_program
    return if @time == 0
    @x = (@x * (@time - 1) + @target_x) / @time
    @y = (@y * (@time - 1) + @target_y) / @time
    @zoom = (@zoom * (@time - 1) + @target_zoom) / @time
    @time -= 1
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update_program
    update_program_switch if @program_switch != []
    update_program_se     if @program_se != []
    update_program_shake  if @program_shake != []
    update_program_color  if @program_color != []
  end
end
 
#==============================================================================
# ■ Scene_Battle
#------------------------------------------------------------------------------
# 　バトル画面の処理を行うクラスです。
#==============================================================================
class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  # ● フレーム更新（基本）
  #--------------------------------------------------------------------------
  alias update_basic_scene_battle_n03 update_basic
  def update_basic
    update_basic_scene_battle_n03
    $sv_camera.update
    $sv_camera.wait = N03::TURN_END_WAIT + 1 if $sv_camera.win_wait
    camera_wait
  end
  #--------------------------------------------------------------------------
  # ● カメラウェイト
  #--------------------------------------------------------------------------
  def camera_wait
    process_event if $sv_camera.event
    $sv_camera.event = false if $sv_camera.event
    while $sv_camera.wait != 0
      Graphics.update
      Input.update
      update_all_windows
      $game_timer.update
      $game_troop.update
      $sv_camera.update
      @spriteset.update
      update_info_viewport
      update_message_open
      $sv_camera.wait -= 1 if $sv_camera.wait > 0
      $sv_camera.wait = 1 if $sv_camera.wait == 0 && @spriteset.effect?
      BattleManager.victory if $sv_camera.win_wait && $sv_camera.wait == 0
    end
  end
  #--------------------------------------------------------------------------
  # ● カメラウェイトのセット
  #--------------------------------------------------------------------------
  def set_camera_wait(time)
    $sv_camera.wait = time
    camera_wait
  end  
  #--------------------------------------------------------------------------
  # ● エフェクト実行が終わるまでウェイト ★再定義
  #--------------------------------------------------------------------------
  def wait_for_effect
  end
  #--------------------------------------------------------------------------
  # ● ターン開始
  #--------------------------------------------------------------------------
  alias turn_start_scene_battle_n03 turn_start
  def turn_start
    turn_start_scene_battle_n03
    N03.camera(nil, N03::BATTLE_CAMERA["ターン開始後"].dup)
  end
  #--------------------------------------------------------------------------
  # ● ターン終了
  #--------------------------------------------------------------------------
  alias turn_end_scene_battle_n03 turn_end
  def turn_end
    turn_end_scene_battle_n03
    for member in $game_troop.members + $game_party.members
      N03.set_damage(member, member.sv.result_damage[0],member.sv.result_damage[1])
      member.sv.result_damage = [0,0]
      @spriteset.set_damage_pop(member) if member.result.hp_damage != 0 or member.result.mp_damage != 0
    end
    set_camera_wait(N03::TURN_END_WAIT)
    N03.camera(nil, N03::BATTLE_CAMERA["ターン開始前"].dup) if $game_party.inputable?
    @log_window.clear
  end
  #--------------------------------------------------------------------------
  # ● スキル／アイテムの使用 ★再定義
  #--------------------------------------------------------------------------
  def use_item
    item = @subject.current_action.item
    display_item(item)
    @subject.use_item(item)
    refresh_status
    @targets = @subject.current_action.make_targets.compact
    @targets = [@subject] if @targets.size == 0
    set_substitute(item)
    for time in item.repeats.times do play_sideview(@targets, item) end
    end_reaction(item)
    display_end_item
  end
  #--------------------------------------------------------------------------
  # ● スキル／アイテム名の表示
  #--------------------------------------------------------------------------
  def display_item(item)
    return @log_window.display_use_item(@subject, item) if N03::BATTLE_LOG
    @log_window.off
    @skill_name_window = Window_Skill_name.new(item.name) unless N03::NO_DISPLAY_SKILL_ID.include?(item.id) && item.is_a?(RPG::Skill)
  end  
  #--------------------------------------------------------------------------
  # ● スキル／アイテム名の表示終了
  #--------------------------------------------------------------------------
  def display_end_item
    @skill_name_window.dispose if @skill_name_window != nil
    @skill_name_window = nil
    set_camera_wait(N03::ACTION_END_WAIT) if @subject.sv.derivation_skill_id == 0
    @log_window.clear if N03::BATTLE_LOG
  end  
  #--------------------------------------------------------------------------
  # ● 反撃／魔法反射／身代わり処理
  #--------------------------------------------------------------------------
  def end_reaction(item)
    end_substitute if @substitute != nil
    set_reflection(item) if @reflection_data != nil
    set_counter_attack if @counter_attacker != nil
  end  
  #--------------------------------------------------------------------------
  # ● 反撃の発動 ★再定義
  #--------------------------------------------------------------------------
  def invoke_counter_attack(target, item)
    return if @subject.sv.counter_id != 0
    @counter_attacker = [] if @counter_attacker == nil
    return apply_item_effects(apply_substitute(target, item), item) if !target.movable?
    @log_window.add_text(sprintf(Vocab::CounterAttack, target.name)) if N03::BATTLE_LOG
    target.sv.counter_id = target.sv.counter_skill_id
    @counter_attacker.push(target)
  end
  #--------------------------------------------------------------------------
  # ● 魔法反射の発動 ★再定義
  #--------------------------------------------------------------------------
  def invoke_magic_reflection(target, item)
    return if @subject.sv.reflection_id != 0
    @log_window.add_text(sprintf(Vocab::MagicReflection, target.name)) if N03::BATTLE_LOG
    target.sv.reflection_id = target.sv.reflection_anime_id
  end
  #--------------------------------------------------------------------------
  # ● 身代わりの適用 ★再定義
  #--------------------------------------------------------------------------
  def apply_substitute(target, item)
    return target if @substitute == nil
    return target if !check_substitute(target, item)
    return @substitute
  end
  #--------------------------------------------------------------------------
  # ● 身代わりセット
  #--------------------------------------------------------------------------
  def set_substitute(item)
    @substitute = N03.get_enemy_unit(@subject).substitute_battler
    return if @substitute == nil
    s_targets = []
    for i in 0...@targets.size
      next if @targets[i] == @substitute
      next if !check_substitute(@targets[i], item)
      @log_window.add_text(sprintf(Vocab::Substitute, @substitute.name, @targets[i].name))
      @targets[i].sv.start_action(@targets[i].sv.substitute_receiver_start_action)
      s_targets.push(@targets[i])
      @targets[i] = @substitute
    end
    return @substitute = nil if s_targets == []
    @substitute.sv.set_target(s_targets)
    @substitute.sv.start_action(@substitute.sv.substitute_start_action)
  end  
  #--------------------------------------------------------------------------
  # ● 身代わり終了
  #--------------------------------------------------------------------------
  def end_substitute
    for member in @substitute.sv.target_battler
      member.sv.start_action(member.sv.substitute_receiver_end_action)
    end  
    @substitute.sv.start_action(@substitute.sv.substitute_end_action)
    @substitute = nil
  end
  #--------------------------------------------------------------------------
  # ● 反撃
  #--------------------------------------------------------------------------
  def set_counter_attack
    pre_subject = @subject
    for attacker in @counter_attacker
      @subject = attacker
      item = $data_skills[attacker.sv.counter_skill_id]
      play_sideview([pre_subject], item) 
    end
    # 同一カウンター者を考慮してカウンターIDの初期化はアクション後に実行
    for attacker in @counter_attacker do attacker.sv.counter_id = 0 end
    @subject = pre_subject
    @counter_attacker = nil
  end
  #--------------------------------------------------------------------------
  # ● 魔法反射
  #--------------------------------------------------------------------------
  def set_reflection(item)
    @log_window.back_to(1)
    for data in @reflection_data
      @subject.sv.damage_action(@subject, item)
      N03.set_damage_anime_data([@subject], @subject, data)
      apply_item_effects(@subject, item)
      @spriteset.set_damage_pop(@subject)
    end
    set_camera_wait(N03.get_anime_time(@reflection_data[0][0]))
    @reflection_data = nil
  end
  #--------------------------------------------------------------------------
  # ● サイドビューアクション実行
  #--------------------------------------------------------------------------
  def play_sideview(targets, item)
    @subject.sv.set_target(targets)
    return if @subject.sv.attack_action(item) == nil
    return if !@subject.movable?
    return if item.scope != 9 && item.scope != 10 && !N03.targets_alive?(targets)
    @subject.sv.start_action(@subject.sv.attack_action(item))
    @subject.sv.unshift_action(@subject.sv.flash_action) if @subject.flash_flg
    @subject.sv.active = true
    @subject.sv.command_action = false
    loop do
      update_basic
      data = @subject.sv.play_data
      @targets = N03.s_targets(@subject) if data[0] == "second_targets_set"
      N03.targets_set(@subject)          if data[0] == "targets_set"
      @immortal = N03.immortaling        if data[0] == "no_collapse" && !N03.dead_attack?(@subject, item)
      @immortal = N03.unimmortaling      if data[0] == "collapse"
      next set_move_anime(item)          if @subject.sv.m_a_data != []
      set_damage(item)                   if @subject.sv.set_damage
      break N03.derived_skill(@subject)  if @subject.sv.derivation_skill_id != 0
      break                              if @subject.sv.action_end or @subject.hidden?
    end
    @immortal = N03.unimmortaling        if @immortal
  end
  #--------------------------------------------------------------------------
  # ● ダメージの実行
  #--------------------------------------------------------------------------
  def set_damage(item)
    targets = @targets
    targets = [@subject.sv.individual_targets[0]] if @subject.sv.individual_targets.size != 0
    for target in targets do damage_anime(targets.dup, target, item) end
    @subject.sv.set_damage = false
    @subject.sv.damage_anime_data = []
  end
  #--------------------------------------------------------------------------
  # ● ダメージ戦闘アニメ処理
  #--------------------------------------------------------------------------
  def damage_anime(targets, target, item)
    @log_window.back_to(1) if @log_window.line_number == 5
    return if item.scope != 9 && item.scope != 10 && target.dead?
    @miss = false
    invoke_item(target,item)
    if target.result.missed
      target.sv.miss_action(@subject, item)
      return @miss = true
    elsif target.result.evaded or target.sv.counter_id != 0
      target.sv.evasion_action(@subject, item)
      return @miss = true
    elsif target.sv.reflection_id != 0
      N03.set_damage_anime_data(targets, target, [target.sv.reflection_id, false, false, true])
      target.sv.reflection_id = 0
      @reflection_data = [] if @reflection_data == nil
      return @reflection_data.push([N03.get_attack_anime_id(-3, @subject), false, false, true])
    end
    target.sv.damage_action(@subject, item)
    N03.set_damage(@subject, -target.result.hp_drain, -target.result.mp_drain) if target != @subject
    @spriteset.set_damage_pop(target)
    @spriteset.set_damage_pop(@subject) if target != @subject && @subject.result.hp_damage != 0 or @subject.result.mp_damage != 0
    N03.set_damage_anime_data(targets, target, @subject.sv.damage_anime_data) if @subject.sv.damage_anime_data != []
  end
  #--------------------------------------------------------------------------
  # ● 飛ばしアニメ処理
  #--------------------------------------------------------------------------
  def set_move_anime(item)
    for data in @subject.sv.m_a_data
      @subject.sv.damage_anime_data = data[4]
      hit_targets = []
      for target in data[1]
        damage_anime(data[1], target, item) if data[0]
        hit_targets.push(target) if !@miss
      end
      @miss = false if !data[3]
      @spriteset.set_hit_animation(@subject, data[2], hit_targets, @miss)
    end
    @subject.sv.set_damage = false
    @subject.sv.m_a_data = []
  end
end
 
#==============================================================================
# ■ DataManager
#------------------------------------------------------------------------------
# 　データベースとゲームオブジェクトを管理するモジュールです。
#==============================================================================
module DataManager
  #--------------------------------------------------------------------------
  # ● 各種ゲームオブジェクトの作成 ★再定義
  #--------------------------------------------------------------------------
  def self.create_game_objects
    $game_temp          = Game_Temp.new
    $game_system        = Game_System.new
    $game_timer         = Game_Timer.new
    $game_message       = Game_Message.new
    $game_switches      = Game_Switches.new
    $game_variables     = Game_Variables.new
    $game_self_switches = Game_SelfSwitches.new
    $game_actors        = Game_Actors.new
    $game_party         = Game_Party.new
    $game_troop         = Game_Troop.new
    $game_map           = Game_Map.new
    $game_player        = Game_Player.new
    $sv_camera          = Battle_Camera.new
  end
end
 
#==============================================================================
# ■ BattleManager
#------------------------------------------------------------------------------
# 　戦闘の進行を管理するモジュールです。
#==============================================================================
module BattleManager
  #--------------------------------------------------------------------------
  # ● エンカウント時の処理 ★再定義
  #--------------------------------------------------------------------------
  def self.on_encounter
    @preemptive = (rand < rate_preemptive)
    @surprise = (rand < rate_surprise && !@preemptive)
    $sv_camera.mirror = @surprise if N03::BACK_ATTACK
  end
  #--------------------------------------------------------------------------
  # ● 勝利の処理 ★再定義
  #--------------------------------------------------------------------------
  def self.process_victory
    $sv_camera.win_wait = true
  end  
  #--------------------------------------------------------------------------
  # ● 勝利
  #--------------------------------------------------------------------------
  def self.victory
    $sv_camera.win_wait = false 
    N03.camera(nil, N03::BATTLE_CAMERA["戦闘終了時"].dup)
    for member in $game_party.members do member.sv.start_action(member.sv.win) if member.movable? end
    play_battle_end_me
    replay_bgm_and_bgs
    $game_message.add(sprintf(Vocab::Victory, $game_party.name))
    display_exp
    gain_gold
    gain_drop_items
    gain_exp
    SceneManager.return
    battle_end(0)
    return true
  end
  #--------------------------------------------------------------------------
  # ● 逃走の処理 ★再定義
  #--------------------------------------------------------------------------
  def self.process_escape
    $game_message.add(sprintf(Vocab::EscapeStart, $game_party.name))
    success = @preemptive ? true : (rand < @escape_ratio)
    Sound.play_escape
    if success
      process_abort
      for member in $game_party.members do member.sv.start_action(member.sv.escape) if member.movable? end
    else
      @escape_ratio += 0.1
      $game_message.add('\.' + Vocab::EscapeFailure)
      $game_party.clear_actions
      for member in $game_party.members do member.sv.start_action(member.sv.escape_ng) if member.movable? end
    end
    wait_for_message
    return success
  end
  #--------------------------------------------------------------------------
  # ● 次のコマンド入力へ ★再定義
  #--------------------------------------------------------------------------
  def self.next_command
    begin
      if !actor || !actor.next_command
        $game_party.battle_members[@actor_index].sv.command_action = true
        @actor_index += 1
        if @actor_index >= $game_party.members.size
          for member in $game_party.battle_members.reverse
            break member.sv.start_action(member.sv.command_a) if member.inputable?
          end
          return false 
        end
      end
    end until actor.inputable?
    actor.sv.start_action(actor.sv.command_b) if actor != nil && actor.inputable?
    if pre_actor
      pre_actor.sv.start_action(pre_actor.sv.command_a) if pre_actor != nil && pre_actor.inputable?
    end
    return true
  end
  #--------------------------------------------------------------------------
  # ● 前のコマンド入力へ ★再定義
  #--------------------------------------------------------------------------
  def self.prior_command
    begin
      if !actor || !actor.prior_command
        $game_party.battle_members[@actor_index].sv.command_action = false
        @actor_index -= 1
        if @actor_index < 0
          for member in $game_party.battle_members
            break member.sv.start_action(member.sv.command_a) if member.inputable?
          end
          return false 
        end
      end
    end until actor.inputable?
    actor.make_actions if actor.inputable?
    actor.sv.start_action(actor.sv.command_b) if actor.inputable?
    after_actor.sv.start_action(after_actor.sv.command_a) if after_actor != nil && after_actor.inputable?
    return true
  end
  #--------------------------------------------------------------------------
  # ● コマンド入力前のアクターを取得
  #--------------------------------------------------------------------------
  def self.pre_actor
    return if @actor_index == 0
    $game_party.members[@actor_index - 1]
  end
  #--------------------------------------------------------------------------
  # ● コマンド入力後のアクターを取得
  #--------------------------------------------------------------------------
  def self.after_actor
    $game_party.members[@actor_index + 1]
  end
  #--------------------------------------------------------------------------
  # ● 戦闘行動者を前に追加
  #--------------------------------------------------------------------------
  def self.unshift_action_battlers(battler)
    @action_battlers.unshift(battler)
  end
end  
 
#==============================================================================
# ■ Game_Battler
#------------------------------------------------------------------------------
# 　スプライトや行動に関するメソッドを追加したバトラーのクラスです。
#==============================================================================
class Game_Battler < Game_BattlerBase
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_reader   :sv                     # サイドビューデータ
  attr_accessor :flash_flg              # 閃きフラグ
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  alias initialize_game_battler_n03 initialize
  def initialize
    initialize_game_battler_n03
    @sv = SideView.new(self)
  end
  #--------------------------------------------------------------------------
  # ● 現在の戦闘行動を除去
  #--------------------------------------------------------------------------
  alias remove_current_action_game_battler_n03 remove_current_action
  def remove_current_action
    return @sv.derivation_skill_id = 0 if @sv.derivation_skill_id != 0
    remove_current_action_game_battler_n03
  end
  #--------------------------------------------------------------------------
  # ● ターン終了処理
  #--------------------------------------------------------------------------
  alias on_turn_end_game_battler_n03 on_turn_end
  def on_turn_end
    on_turn_end_game_battler_n03
    @sv.add_state = []
    @sv.result_damage = [@result.hp_damage, @result.mp_damage]
  end
  #--------------------------------------------------------------------------
  # ● パラメータ条件比較 data = [種別, 数値, 判別]
  #--------------------------------------------------------------------------
  def comparison_parameter(data)
    return true if data[0][0] == 0
    kind = data[0]
    num = data[1]
    select = data[2]
    case kind
    when  1 ; par = level
    when  2 ; par = mhp
    when  3 ; par = mmp
    when  4 ; par = hp
    when  5 ; par = mp
    when  6 ; par = tp
    when  7 ; par = atk
    when  8 ; par = self.def
    when  9 ; par = mat
    when 10 ; par = mdf
    when 11 ; par = agi
    when 12 ; par = luk
    end
    if num < 0
      case kind
      when  4 ; num = mhp * num / 100
      when  5 ; num = mmp * num / 100
      when  6 ; num = max_tp * num / 100
      end
      num = num.abs
    end  
    case select
    when  0 ; return par == num
    when  1 ; return par < num
    when  2 ; return par > num
    end
  end
  #--------------------------------------------------------------------------
  # ● 装備条件比較 data = [装備種別, タイプID]
  #--------------------------------------------------------------------------
  def comparison_equip(data)
    kind = data[0]
    items = weapons if kind == 0
    items = armors  if kind == 1
    for item in items
      for id in data[1]
        return true if id > 0 && item.is_a?(RPG::Weapon) && item == $data_weapons[id.abs]
        return true if id > 0 && item.is_a?(RPG::Armor) && item == $data_armors[id.abs]
        return true if id < 0 && item.is_a?(RPG::Weapon) && item.wtype_id == id.abs
        return true if id < 0 && item.is_a?(RPG::Armor) && item.stype_id == id.abs
      end
    end
    return false
  end
 
end  
#==============================================================================
# ■ Game_Actor
#------------------------------------------------------------------------------
# 　アクターを扱うクラスです。
#==============================================================================
class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_reader :actor_id                    # ID
  #--------------------------------------------------------------------------
  # ● ID
  #--------------------------------------------------------------------------
  def id
    return @actor_id
  end
  #--------------------------------------------------------------------------
  # ● スプライトを使うか？ ★再定義
  #--------------------------------------------------------------------------
  def use_sprite?
    return true
  end
  #--------------------------------------------------------------------------
  # ● ダメージ効果の実行 ★再定義
  #--------------------------------------------------------------------------
  def perform_damage_effect
    return if !N03::ACTOR_DAMAGE
    $game_troop.screen.start_shake(5, 5, 10)
    @sprite_effect_type = :blink
    Sound.play_actor_damage
  end
 
end
 
#==============================================================================
# ■ Game_Enemy
#------------------------------------------------------------------------------
# 　敵キャラを扱うクラスです。
#==============================================================================
class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_reader :enemy_id                    # ID
  #--------------------------------------------------------------------------
  # ● ID
  #--------------------------------------------------------------------------
  def id
    return @enemy_id
  end
  #--------------------------------------------------------------------------
  # ● レベル
  #--------------------------------------------------------------------------
  def level
    return @sv.level
  end
  #--------------------------------------------------------------------------
  # ● ダメージ効果の実行 ★再定義
  #--------------------------------------------------------------------------
  def perform_damage_effect
    return if !N03::ENEMY_DAMAGE
    @sprite_effect_type = :blink
    Sound.play_enemy_damage
  end
  #--------------------------------------------------------------------------
  # ● 武器
  #--------------------------------------------------------------------------
  def weapons
    weapon1 = $data_weapons[@sv.enemy_weapon1_id]
    weapon2 = $data_weapons[@sv.enemy_weapon2_id]
    return [weapon1, weapon2]
  end
  #--------------------------------------------------------------------------
  # ● 防具
  #--------------------------------------------------------------------------
  def armors
    return [$data_armors[@sv.enemy_shield_id]]
  end
  #--------------------------------------------------------------------------
  # ● 二刀流の判定
  #--------------------------------------------------------------------------
  def dual_wield?
    return $data_weapons[@sv.enemy_weapon2_id] != nil
  end
  #--------------------------------------------------------------------------
  # ● バトラー画像変更
  #--------------------------------------------------------------------------
  def graphics_change(battler_name)
    @battler_name = battler_name
  end
  #--------------------------------------------------------------------------
  # ● 通常攻撃 アニメーション ID の取得
  #--------------------------------------------------------------------------
  def atk_animation_id1
    return weapons[0].animation_id if weapons[0]
    return weapons[1] ? 0 : 1
  end
  #--------------------------------------------------------------------------
  # ● 通常攻撃 アニメーション ID の取得（二刀流：武器２）
  #--------------------------------------------------------------------------
  def atk_animation_id2
    return weapons[1] ? weapons[1].animation_id : 0
  end
end
 
#==============================================================================
# ■ Sprite_Base
#------------------------------------------------------------------------------
# 　アニメーションの表示処理を追加したスプライトのクラスです。
#==============================================================================
class Sprite_Base < Sprite
  #--------------------------------------------------------------------------
  # ● アニメーションの座標更新 (ホーミングあり)
  #--------------------------------------------------------------------------
  def update_animation_position_horming
    return if @action_end_cancel
    ani_ox_set if @horming
    camera_zoom = $sv_camera.zoom
    camera_zoom = 1 if @move_anime
    kind = 1
    kind = -1 if @ani_mirror && !@anime_no_mirror
    cell_data = @animation.frames[@animation.frame_max - (@ani_duration + @ani_rate - 1) / @ani_rate].cell_data
    for i in 0..15
      @ani_sprites[i].x = (@ani_ox + cell_data[i, 1] * kind - $sv_camera.x) * camera_zoom if @ani_sprites[i] != nil && cell_data[i, 1] != nil
      @ani_sprites[i].y = (@ani_oy + cell_data[i, 2] - $sv_camera.y) * camera_zoom if @ani_sprites[i] != nil && cell_data[i, 2] != nil
    end
  end
  #--------------------------------------------------------------------------
  # ● アニメーション元の座標をセット
  #--------------------------------------------------------------------------
  def ani_ox_set
    if !SceneManager.scene_is?(Scene_Battle)
      @real_x = x
      @real_y = y
    end
    @ani_ox = @real_x - ox + width / 2
    @ani_oy = @real_y - oy + height / 2
    @ani_oy -= height / 2 if @animation.position == 0
    @ani_oy += height / 2 if @animation.position == 2
  end
  #--------------------------------------------------------------------------
  # ● アニメーションの更新
  #--------------------------------------------------------------------------
  alias update_animation_sprite_base_n03 update_animation
  def update_animation
    update_animation_position_horming if animation? && SceneManager.scene_is?(Scene_Battle) && @animation.position != 3
    update_animation_sprite_base_n03
  end
  #--------------------------------------------------------------------------
  # ● アニメーションの原点設定 ★再定義
  #--------------------------------------------------------------------------
  def set_animation_origin
    return ani_ox_set if @animation.position != 3
    if viewport == nil
      @ani_ox = Graphics.width / 2
      @ani_oy = Graphics.height / 2
    else
      @ani_ox = viewport.rect.width / 2
      @ani_oy = viewport.rect.height / 2
    end
  end
  #--------------------------------------------------------------------------
  # ● アニメーションスプライトの設定 ★再定義
  #--------------------------------------------------------------------------
  def animation_set_sprites(frame)
    camera_zoom = 1
    camera_zoom = $sv_camera.zoom if @anime_camera_zoom && @animation.position != 3 && SceneManager.scene_is?(Scene_Battle)
    camera_x = $sv_camera.x
    camera_y = $sv_camera.y
    camera_x = camera_y = 0 if @animation.position == 3 or !SceneManager.scene_is?(Scene_Battle)
    plus_z = 5
    plus_z = 1000 if @animation.position == 3
    plus_z = -17 if @plus_z != nil && @plus_z == false
    plus_z = -self.z + 10 if @plus_z != nil && @plus_z == false && @animation.position == 3
    cell_data = frame.cell_data
    @ani_sprites.each_with_index do |sprite, i|
      next unless sprite
      pattern = cell_data[i, 0]
      if !pattern || pattern < 0
        sprite.visible = false
        next
      end
      sprite.bitmap = pattern < 100 ? @ani_bitmap1 : @ani_bitmap2
      sprite.visible = true
      sprite.src_rect.set(pattern % 5 * 192,
        pattern % 100 / 5 * 192, 192, 192)
      if @ani_mirror && !@anime_no_mirror
        sprite.x = (@ani_ox - cell_data[i, 1] - camera_x) * camera_zoom
        sprite.y = (@ani_oy + cell_data[i, 2] - camera_y) * camera_zoom
        sprite.angle = (360 - cell_data[i, 4])
        sprite.mirror = (cell_data[i, 5] == 0)
      else
        sprite.x = (@ani_ox + cell_data[i, 1] - camera_x) * camera_zoom
        sprite.y = (@ani_oy + cell_data[i, 2] - camera_y) * camera_zoom
        sprite.angle = cell_data[i, 4]
        sprite.mirror = (cell_data[i, 5] == 1)
      end
      sprite.z = self.z + plus_z + i
      sprite.ox = 96
      sprite.oy = 96
      sprite.zoom_x = cell_data[i, 3] * camera_zoom / 100.0
      sprite.zoom_y = cell_data[i, 3] * camera_zoom/ 100.0
      sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
      sprite.blend_type = cell_data[i, 7]
    end
  end
  #--------------------------------------------------------------------------
  # ● 子スプライトフラグ
  #--------------------------------------------------------------------------
  def set(battler, horming, camera_zoom, no_mirror)
    @battler = battler
    @next = true
    self.bitmap = Bitmap.new(@battler.sv.cw, @battler.sv.ch)
    self.ox = bitmap.width / 2
    self.oy = bitmap.height
    @horming = horming
    @anime_camera_zoom = camera_zoom
    @anime_no_mirror = no_mirror
    @battler.sv.reset_anime_data
  end  
  #--------------------------------------------------------------------------
  # ● 子スプライト座標セット
  #--------------------------------------------------------------------------
  def set_position(z, zoom_x, zoom_y, real_x, real_y)
    self.z = z
    self.zoom_x = zoom_x
    self.zoom_y = zoom_y
    @real_x = real_x
    @real_y = real_y
  end
  #--------------------------------------------------------------------------
  # ● 他スプライトへのタイミング処理
  #--------------------------------------------------------------------------
  def other_process_timing(timing)
    se_flag = true
    se_flag = @se_flag if @se_flag != nil
    @battler.sv.timing.push([se_flag, timing.dup])
  end
  #--------------------------------------------------------------------------
  # ● 他バトラーへのタイミング処理
  #--------------------------------------------------------------------------
  def target_battler_process_timing(timing)
    for target in @timing_targets
      target.sv.timing.push([false, timing.dup])
    end  
  end
  #--------------------------------------------------------------------------
  # ● SE とフラッシュのタイミング処理
  #--------------------------------------------------------------------------
  alias animation_process_timing_sprite_base_n03 animation_process_timing
  def animation_process_timing(timing)
    target_battler_process_timing(timing) if @timing_targets && @timing_targets != []
    return other_process_timing(timing) if @next != nil
    animation_process_timing_sprite_base_n03(timing)
  end
  #--------------------------------------------------------------------------
  # ● アニメーションの解放
  #--------------------------------------------------------------------------
  alias dispose_animation_sprite_base_n03 dispose_animation
  def dispose_animation
    dispose_animation_sprite_base_n03
  end
end
 
 
#==============================================================================
# ■ Sprite_Battler
#------------------------------------------------------------------------------
# 　バトラー表示用のスプライトです。
#==============================================================================
class Sprite_Battler < Sprite_Base
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数　
  #--------------------------------------------------------------------------
  attr_accessor   :removing             # パーティ離脱中
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  alias initialize_sprite_battler_n03 initialize
  def initialize(viewport, battler = nil)
    initialize_sprite_battler_n03(viewport, battler)
    @real_x = @real_y = 0
    update_bitmap if @battler != nil
  end
  #--------------------------------------------------------------------------
  # ● アニメーションの開始 ★再定義
  #--------------------------------------------------------------------------
  def start_animation(animation, mirror = false)
    return next_animation(animation, mirror) if animation?
    @animation = animation
    if @animation
      @horming = @battler.sv.anime_horming
      @anime_camera_zoom = @battler.sv.anime_camera_zoom
      @anime_no_mirror = @battler.sv.anime_no_mirror
      @timing_targets = @battler.sv.timing_targets
      @plus_z = @battler.sv.anime_plus_z
      @battler.sv.reset_anime_data
      @ani_mirror = mirror
      set_animation_rate
      @ani_duration = @animation.frame_max * @ani_rate + 1
      load_animation_bitmap
      make_animation_sprites
      set_animation_origin
    end
  end
  #--------------------------------------------------------------------------
  # ● 次のアニメを開始
  #--------------------------------------------------------------------------
  def next_animation(animation, mirror)
    @next_anime = [] if @next_anime == nil
    @next_anime.push(Sprite_Base.new(viewport))
    @next_anime[@next_anime.size - 1].set(battler, @battler.sv.anime_horming, @battler.sv.anime_camera_zoom, @battler.sv.anime_no_mirror)
    @next_anime[@next_anime.size - 1].set_position(self.z, self.zoom_x, self.zoom_y, @real_x, @real_y)
    @next_anime[@next_anime.size - 1].start_animation(animation, mirror)
  end
  #--------------------------------------------------------------------------
  # ● 影グラフィック作成
  #--------------------------------------------------------------------------
  def create_shadow
    reset_shadow
    return if @battler.sv.shadow == false
    @shadow = Sprite.new(viewport) if @shadow == nil
    @shadow.bitmap = Cache.character(@battler.sv.shadow)
    @shadow.ox = @shadow.bitmap.width / 2
    @shadow.oy = @shadow.bitmap.height / 2
  end
  #--------------------------------------------------------------------------
  # ● 影グラフィック初期化
  #--------------------------------------------------------------------------
  def reset_shadow
    return if @shadow == nil
    @shadow.dispose
    @shadow = nil
  end  
  #--------------------------------------------------------------------------
  # ● 転送元ビットマップの更新 ★再定義
  #--------------------------------------------------------------------------
  def update_bitmap
    update_bitmap_enemy if !@battler.actor?
    update_bitmap_actor if @battler.actor?
    update_src_rect if @battler != nil
    update_color if @battler != nil
  end
  #--------------------------------------------------------------------------
  # ● 転送元ビットマップ:エネミー
  #--------------------------------------------------------------------------
  def update_bitmap_enemy
    if @battler.battler_name != @battler_name or @battler.battler_hue != @battler_hue
      @battler_name = @battler.battler_name
      @battler_hue = @battler.battler_hue
      @battler_graphic_file_index = @battler.sv.graphic_file_index
      @graphic_mirror_flag = @battler.sv.graphic_mirror_flag
      self.bitmap = Cache.battler(@battler_name + @battler_graphic_file_index, @battler_hue)
      @battler.sv.setup(self.bitmap.width, self.bitmap.height, @battler_id != @battler.id)
      create_shadow
      init_visibility
      @battler_id = @battler.id
    end
  end  
  #--------------------------------------------------------------------------
  # ● 転送元ビットマップ:アクター
  #--------------------------------------------------------------------------
  def update_bitmap_actor
    if @battler.character_name != @battler_name or @battler.character_index != @battler_index
      @battler_name = @battler.character_name
      @battler_index = @battler.character_index
      @battler_graphic_file_index = @battler.sv.graphic_file_index
      @graphic_mirror_flag = @battler.sv.graphic_mirror_flag
      self.bitmap = Cache.character(@battler_name + @battler_graphic_file_index)
      @battler.sv.setup(self.bitmap.width, self.bitmap.height, @battler_id != @battler.id)
      create_shadow
      init_visibility
      @battler_id = @battler.id
    end
  end
  #--------------------------------------------------------------------------
  # ● 可視状態の初期化 ★再定義
  #--------------------------------------------------------------------------
  def init_visibility
    @battler_visible = @battler.alive?
    @battler_visible = true if @battler.sv.state(1) != "敵コラプス"
    @battler_visible = false if @battler.hidden?
    @battler.sv.opacity = 0 unless @battler_visible
    self.opacity = 0 unless @battler_visible
    self.opacity = 255 if @battler_visible
    @battler.sv.weapon_visible = @battler_visible
  end
  #--------------------------------------------------------------------------
  # ● 転送元矩形の更新
  #--------------------------------------------------------------------------
  def update_src_rect
    return if @battler.sv.collapse
    if @battler_graphic_file_index != @battler.sv.graphic_file_index
      @battler_graphic_file_index = @battler.sv.graphic_file_index
      self.bitmap = Cache.character(@battler_name + @battler_graphic_file_index) if @battler.actor?
      self.bitmap = Cache.battler(@battler_name + @battler_graphic_file_index, @battler_hue) if !@battler.actor?
      @battler.sv.set_graphics(self.bitmap.width, self.bitmap.height)
    end
    anime_off if @battler.sv.anime_off
    self.src_rect.set(@battler.sv.sx, @battler.sv.sy, @battler.sv.cw, @battler.sv.ch)
    self.opacity = @battler.sv.opacity if @battler_visible
    set_process_timing(@battler.sv.timing) if @battler && @battler.sv.timing != []
  end
  #--------------------------------------------------------------------------
  # ● 位置の更新 ★再定義
  #--------------------------------------------------------------------------
  def update_position
    @real_x = @battler.sv.x / 100
    @real_y = (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.c - @battler.sv.oy_adjust)/ 100
    self.x = @real_x - $sv_camera.x
    self.y = @real_y - $sv_camera.y
    self.z = @battler.sv.z - @battler.sv.c / 100
    if @battler.sv.h <= 0
      self.x += $sv_camera.sx / 100
      self.y += $sv_camera.sy / 100
    end  
    self.x *= $sv_camera.zoom
    self.y *= $sv_camera.zoom
  end
  #--------------------------------------------------------------------------
  # ● 原点の更新 ★再定義
  #--------------------------------------------------------------------------
  def update_origin
    return if !bitmap or @battler.sv.collapse
    self.ox = @battler.sv.ox
    self.oy = @battler.sv.oy
    self.angle = @battler.sv.angle
    self.zoom_x = @battler.sv.zoom_x * $sv_camera.zoom
    self.zoom_y = @battler.sv.zoom_y * $sv_camera.zoom
    self.mirror = @battler.sv.mirror if !@graphic_mirror_flag
    self.mirror = !@battler.sv.mirror if @graphic_mirror_flag
  end
  #--------------------------------------------------------------------------
  # ● 影グラフィックの更新
  #--------------------------------------------------------------------------
  def update_shadow
    @shadow.visible = @battler.sv.shadow_visible
    @shadow.opacity = @battler.sv.opacity if @battler.sv.opacity_data[3]
    @shadow.opacity = self.opacity if !@battler.sv.opacity_data[3]
    @shadow.x = @real_x - $sv_camera.x
    @shadow.y = (@battler.sv.y - @battler.sv.c)/ 100 - $sv_camera.y
    @shadow.z = @battler.sv.z - 10
    @shadow.zoom_x = $sv_camera.zoom
    @shadow.zoom_y = $sv_camera.zoom
    @shadow.x += $sv_camera.sx / 100
    @shadow.y += $sv_camera.sy / 100
    @shadow.x *= $sv_camera.zoom
    @shadow.y *= $sv_camera.zoom
    @shadow.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
  end
  #--------------------------------------------------------------------------
  # ● ふきだしの更新
  #--------------------------------------------------------------------------
  def update_balloon
    if @battler.sv.balloon_data == [] && @balloon
      @balloon_data = []
      @balloon.dispose
      return @balloon = nil
    elsif @battler.sv.balloon_data != [] && @battler.sv.balloon_data != @balloon_data
      @balloon_data = @battler.sv.balloon_data
      @balloon = Sprite.new(self.viewport)
      @balloon.bitmap = Cache.system("Balloon")
      @balloon.zoom_x = @balloon_data[3]
      @balloon.zoom_y = @balloon_data[3]
      @balloon.ox = 32 if @battler.sv.mirror
      @balloon.oy = 16
      @balloon_count = 0
    end
    return if !@balloon
    @balloon.opacity = self.opacity
    @balloon.x = self.x
    @balloon.y = self.y - @battler.sv.ch * $sv_camera.zoom
    @balloon.z = self.z + 20
    @balloon.src_rect.set(32 + @balloon_count / @balloon_data[2] * 32, @balloon_data[1] * 32, 32, 32) if @balloon_count % @balloon_data[2] == 0
    @balloon.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
    @balloon_count += 1
    @balloon_count = 0 if @balloon_count == @balloon_data[2] * 7
  end
  #--------------------------------------------------------------------------
  # ● 色調変更の更新
  #--------------------------------------------------------------------------
  def update_color
    color_set if @battler.sv.color_set != []
    return if @color_data == nil
    @color_data[4] -= 1
    if @color_data[4] == 0 && @color_data[5] != 0
      @color_data[4] = @color_data[5]
      @color_data[5] = 0
      @color_data[6] = [0,0,0,0]
    elsif @color_data[4] == 0
      @remain_color_data = @color_data
      @battler.sv.color = @color_data.dup
      return @color_data = nil
    end  
    for i in 0..3
      @color_data[i] = (@color_data[i] * (@color_data[4] - 1) + @color_data[6][i]) / @color_data[4]
    end  
    @battler.sv.color = @color_data.dup
    self.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3])
  end
  #--------------------------------------------------------------------------
  # ● 残像の更新
  #--------------------------------------------------------------------------
  def update_mirage
    if @battler.sv.mirage == [] && @mirages
      @mirage_data = []
      for mirage in @mirages do mirage.dispose end
      return @mirages = nil
    elsif @battler.sv.mirage != [] && @battler.sv.mirage != @mirage_data
      @mirage_data = @battler.sv.mirage
      @mirages = []
      for i in 0...@mirage_data[1] do @mirages[i] = Sprite.new(self.viewport) end
      @mirage_count = 0
    end
    return if !@mirages
    @mirage_count += 1
    @mirage_count = 0 if @mirage_count == @mirage_data[2] * @mirages.size
    for i in 0...@mirages.size
      mirage_body(@mirages[i], @mirage_data[4]) if @mirage_count == 1 + i * @mirage_data[2]
    end
  end
  #--------------------------------------------------------------------------
  # ● 残像本体
  #--------------------------------------------------------------------------
  def mirage_body(body, opacity)
    body.bitmap = self.bitmap.dup
    body.x = self.x
    body.y = self.y
    body.ox = self.ox
    body.oy = self.oy
    body.z = self.z - 20
    body.mirror = self.mirror
    body.angle = self.angle
    body.opacity = opacity * self.opacity / 255
    body.zoom_x = self.zoom_x
    body.zoom_y = self.zoom_y   
    body.src_rect.set(@battler.sv.sx, @battler.sv.sy, @battler.sv.cw, @battler.sv.ch)
    body.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
  end   
  #--------------------------------------------------------------------------
  # ● 次のアニメを更新
  #--------------------------------------------------------------------------
  def update_next_anime
    return if !@next_anime
    for anime in @next_anime
      anime.update
      anime.set_position(self.z, self.zoom_x, self.zoom_y, @real_x, @real_y) if @horming
      anime.dispose if !anime.animation?
      @next_anime.delete(anime) if !anime.animation?
    end  
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  alias update_sprite_battler_n03 update
  def update
    @battler.sv.update if @battler
    update_sprite_battler_n03
    update_next_anime
    update_shadow  if @battler && @shadow
    update_mirage  if @battler
    update_balloon if @battler
    update_remove if @battler && @removing && @battler.sv.change_up
  end
  #--------------------------------------------------------------------------
  # ● 戦闘アニメ消去
  #--------------------------------------------------------------------------
  def anime_off
    @battler.sv.anime_off = false
    dispose_animation
    for anime in @next_anime do anime.dispose_animation end if @next_anime
  end
  #--------------------------------------------------------------------------
  # ● バトラー入れ替え
  #--------------------------------------------------------------------------
  def remove
    @battler.sv.start_action(@battler.sv.remove_action)
    $sv_camera.wait = 40
    @battler.sv.add_action("eval('set_change')")
    @removing = true
  end
  #--------------------------------------------------------------------------
  # ● バトラー入れ替えの更新
  #--------------------------------------------------------------------------
  def update_remove
    @battler.sv.change_up = false
    @removing = false
    @battler = nil
  end  
  #--------------------------------------------------------------------------
  # ● バトラー加入
  #--------------------------------------------------------------------------
  def join(join_battler)
    $sv_camera.wait = 30
    @battler = join_battler
    @battler_name = @battler.character_name
    @battler_index = @battler.character_index
    @battler_graphic_file_index = @battler.sv.graphic_file_index
    self.bitmap = Cache.character(@battler_name)
    @battler.sv.setup(self.bitmap.width, self.bitmap.height, true)
    create_shadow
    init_visibility
  end
  #--------------------------------------------------------------------------
  # ● 通常の設定に戻す ★再定義
  #--------------------------------------------------------------------------
  def revert_to_normal
    self.blend_type = 0
    self.opacity = 255
  end
  #--------------------------------------------------------------------------
  # ● 崩壊エフェクトの更新
  #--------------------------------------------------------------------------
  alias update_collapse_sprite_battler_n03 update_collapse
  def update_collapse
    return if @battler.sv.state(1) != "敵コラプス"
    update_collapse_sprite_battler_n03
    @battler.sv.weapon_visible = false
  end
  #--------------------------------------------------------------------------
  # ● ボス崩壊エフェクトの更新 ★再定義
  #--------------------------------------------------------------------------
  def update_boss_collapse
    @effect_duration = @battler.sv.ch if @effect_duration >= @battler.sv.ch
    alpha = @effect_duration * 120 / @battler.sv.ch
    self.ox = @battler.sv.cw / 2 + @effect_duration % 2 * 4 - 2
    self.blend_type = 1
    self.color.set(255, 255, 255, 255 - alpha)
    self.opacity = alpha
    self.src_rect.y -= 1
    Sound.play_boss_collapse2 if @effect_duration % 20 == 19
  end
  #--------------------------------------------------------------------------
  # ● 別スプライトからのタイミング処理
  #--------------------------------------------------------------------------
  def set_process_timing(timing_data)
    for data in timing_data
      set_timing(data[0],data[1])
    end
    @battler.sv.timing = []
  end
  #--------------------------------------------------------------------------
  # ● タイミング処理
  #--------------------------------------------------------------------------
  def set_timing(se_flag, data)
    @ani_rate = 4
    data.se.play if se_flag
    case data.flash_scope
    when 1 ;self.flash(data.flash_color, data.flash_duration * @ani_rate)
    when 2 ;viewport.flash(data.flash_color, data.flash_duration * @ani_rate) if viewport
    when 3 ;self.flash(nil, data.flash_duration * @ani_rate)
    end
  end
  #--------------------------------------------------------------------------
  # ● 色調変更
  #--------------------------------------------------------------------------
  def color_set
    set = @battler.sv.color_set
    @battler.sv.color_set= []
    set[4] = 1 if set[4] == 0
    @remain_color_data = [0,0,0,0] if @remain_color_data == nil
    @color_data = @remain_color_data
    @color_data[4] = set[4]
    @color_data[5] = set[5]
    @color_data[6] = set
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  alias dispose_sprite_battler_n03 dispose
  def dispose
    dispose_sprite_battler_n03
    @shadow.dispose if @shadow != nil
    @balloon.dispose if @balloon != nil
    for mirage in @mirages do mirage.dispose end if @mirages != nil
    for anime in @next_anime do anime.dispose end if @next_anime
  end
end
 
 
#==============================================================================
# ■ Spriteset_Battle
#------------------------------------------------------------------------------
# 　バトル画面のスプライトをまとめたクラスです。
#==============================================================================
class Spriteset_Battle
  #--------------------------------------------------------------------------
  # ● 戦闘背景（床）スプライトの作成 ★再定義
  #--------------------------------------------------------------------------
  def create_battleback1
    @back1_sprite = Sprite_Battle_Back.new(@viewport1, 1, battleback1_name)
    @back1_sprite.set_graphics(battleback1_bitmap) if battleback1_name != nil
    @back1_sprite.z = 0
  end
  #--------------------------------------------------------------------------
  # ● 戦闘背景（壁）スプライトの作成 ★再定義
  #--------------------------------------------------------------------------
  def create_battleback2
    @back2_sprite = Sprite_Battle_Back.new(@viewport1, 2, battleback2_name)
    @back2_sprite.set_graphics(battleback2_bitmap) if battleback2_name != nil
    @back2_sprite.z = 1
  end
  #--------------------------------------------------------------------------
  # ● アクタースプライトの作成 ★再定義
  #--------------------------------------------------------------------------
  def create_actors
    @actor_sprites = []
    for i in 0...$game_party.max_battle_members
      @actor_sprites[i] = Sprite_Battler.new(@viewport1, $game_party.members[i])
    end
    @effect_sprites = Spriteset_Sideview.new(@viewport1)
  end
  #--------------------------------------------------------------------------
  # ● アクタースプライトの更新 ★再定義
  #--------------------------------------------------------------------------
  def update_actors
    @actor_sprites.each_with_index do |sprite, i|
      sprite_join($game_party.members[i], sprite) if sprite.battler == nil && sprite.battler != $game_party.members[i]
      sprite.remove if sprite.battler != nil && !sprite.removing && sprite.battler != $game_party.members[i]
      sprite.update
    end
    @effect_sprites.update
    update_program
  end
  #--------------------------------------------------------------------------
  # ● メンバーを加える
  #--------------------------------------------------------------------------
  def sprite_join(member, sprite)
    for sp in @actor_sprites
      sp.update_remove if member == sp.battler && !sp.battler.sv.change_up
    end
    sprite.join(member)
  end 
  #--------------------------------------------------------------------------
  # ● バトルプログラムの更新
  #--------------------------------------------------------------------------
  def update_program
    return if $sv_camera.program_scroll == []
    for data in  $sv_camera.program_scroll
      @back1_sprite.start_back_data(data) if data[2] == 1
      @back2_sprite.start_back_data(data) if data[2] == 2
    end
    $sv_camera.program_scroll = []
  end
  #--------------------------------------------------------------------------
  # ● ヒット時の戦闘アニメ実行
  #--------------------------------------------------------------------------
  def set_hit_animation(battler, weapon_index, hit_targets, miss)
    @effect_sprites.set_hit_animation(battler, weapon_index, hit_targets, miss)
  end
  #--------------------------------------------------------------------------
  # ● ダメージPOP
  #--------------------------------------------------------------------------
  def set_damage_pop(target)
    @effect_sprites.set_damage_pop(target)
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  alias dispose_spriteset_battle_n03 dispose
  def dispose
    dispose_spriteset_battle_n03
    @effect_sprites.dispose
  end
 
 
 
end
 
 
#==============================================================================
# ■ Window_BattleLog
#------------------------------------------------------------------------------
# 　戦闘の進行を実況表示するウィンドウです。
#==============================================================================
class Window_BattleLog < Window_Selectable
  #--------------------------------------------------------------------------
  # ● ウェイト ★再定義
  #--------------------------------------------------------------------------
  def wait
  end
  #--------------------------------------------------------------------------
  # ● ウェイトとクリア ★再定義
  #--------------------------------------------------------------------------
  def wait_and_clear
    $sv_camera.wait = 10
  end
  #--------------------------------------------------------------------------
  # ● 行動結果の表示 ★再定義
  #--------------------------------------------------------------------------
  def display_action_results(target, item)
    if target.result.used
      last_line_number = line_number
      display_critical(target, item)
      display_damage(target, item)
      display_affected_status(target, item)
      display_failure(target, item)
    end
    off if !N03::BATTLE_LOG
  end
  #--------------------------------------------------------------------------
  # ● ウインドウ非表示
  #--------------------------------------------------------------------------
  def off
    @back_sprite.visible = self.visible = false
  end
end
#==============================================================================
# ■ Game_Interpreter
#------------------------------------------------------------------------------
# 　イベントコマンドを実行するインタプリタです。
#==============================================================================
class Game_Interpreter
  #--------------------------------------------------------------------------
  # ● スイッチの操作
  #--------------------------------------------------------------------------
  alias command_121_game_interpreter_n03 command_121
  def command_121
    command_121_game_interpreter_n03
    $sv_camera.program_check
  end
end

#==============================================================================


# ■ Sideview Ver100


#------------------------------------------------------------------------------


# 　サイドビューバトラーを管理するクラスです。


#==============================================================================


class SideView


  #--------------------------------------------------------------------------


  # ● 公開インスタンス変数　


  #--------------------------------------------------------------------------


  attr_accessor   :x                    # 画面X座標


  attr_accessor   :y                    # 画面Y座標


  attr_accessor   :z                    # 画面Z座標


  attr_accessor   :h                    # 高さ座標


  attr_accessor   :j                    # ジャンプ座標


  attr_accessor   :c                    # カーブ座標


  attr_accessor   :ox                   # 横原点


  attr_accessor   :oy                   # 縦原点


  attr_accessor   :oy_adjust            # 縦原点補正


  attr_accessor   :angle                # 回転角度


  attr_accessor   :zoom_x               # 横の拡大率


  attr_accessor   :zoom_y               # 縦の拡大率


  attr_accessor   :pattern_w            # セル横位置（矩形内）


  attr_accessor   :pattern_h            # セル縦位置（矩形内）


  attr_accessor   :sx                   # セル横位置（画像全体）


  attr_accessor   :sy                   # セル縦位置（画像全体）


  attr_accessor   :pattern_type         # セル更新タイプ


  attr_accessor   :pattern_time         # セル更新間隔


  attr_accessor   :graphic_name         # バトラー画像ファイル名


  attr_accessor   :graphic_file_index   # バトラー画像ファイル名インデックス


  attr_accessor   :graphic_index        # バトラー画像インデックス


  attr_accessor   :cw                   # セル横矩形


  attr_accessor   :ch                   # セル縦矩形


  attr_accessor   :shadow_visible       # 影表示


  attr_accessor   :weapon_visible       # 武器表示


 


  attr_accessor   :wait                 # 次の動作待ち時間


  attr_accessor   :weapon_index         # 表示中の武器画像インデックス配列


  attr_accessor   :weapon_end           # 武器アニメ終了フラグ


  attr_accessor   :force_action         # 強制アクション


  attr_accessor   :target_battler       # ターゲットバトラー情報


  attr_accessor   :second_targets       # セカンドターゲット情報


  attr_accessor   :m_a_targets          # アニメ飛ばしターゲット情報


  attr_accessor   :individual_targets   # 個別処理ターゲットバトラー情報


  attr_accessor   :effect_data          # エフェクトデータ


  attr_accessor   :anime_id             # アニメID配列


  attr_accessor   :anime_move_id        # 飛ばしアニメID配列


  attr_accessor   :mirror               # 反転フラグ


  attr_accessor   :opacity              # 透明度


  attr_accessor   :opacity_data         # 透明度操作情報


  attr_accessor   :set_damage           # バトルシーンでのダメージ処理


  attr_accessor   :m_a_data             # アニメ飛ばし情報


  attr_accessor   :m_a_starter          # アニメ飛ばし開始ターゲット情報


  attr_accessor   :action_end           # バトルシーンでの行動終了


  attr_accessor   :damage_anime_data    # ダメージ戦闘アニメのデータ


  attr_accessor   :anime_no_mirror      # 戦闘アニメの反転禁止フラグ


  attr_accessor   :anime_horming        # 戦闘アニメのホーミングフラグ


  attr_accessor   :anime_camera_zoom    # 戦闘アニメがカメラに合わせて拡大縮小するか


  attr_accessor   :anime_plus_z         # 戦闘アニメZ座標補正


  attr_accessor   :derivation_skill_id  # スキル派生ID


  attr_accessor   :immortal             # 不死身フラグ


  attr_accessor   :mirage               # 残像データ


  attr_accessor   :balloon_data         # ふきだしデータ


  attr_accessor   :timing               # 別バトラーからのタイミングデータ


  attr_accessor   :timing_targets       # タイミングデータを渡す別バトラー


  attr_accessor   :color_set            # 色調変更データ


  attr_accessor   :color                # 色調データ


  attr_accessor   :change_up            # 画像変更フラグ


  attr_accessor   :hit                  # 被攻撃回数


  attr_accessor   :add_state            # 何度も付加ステートの表示を防ぐフラグ


  attr_accessor   :counter_id           # カウンター時のスキルID


  attr_accessor   :reflection_id        # 魔法反射時のアニメID


  attr_accessor   :result_damage        # ターン終了時のHP変動データ


  attr_accessor   :active               # 行動権


  attr_accessor   :anime_off            # 戦闘アニメ消去


  attr_accessor   :command_action       # コマンドアクションフラグ


 


  attr_accessor   :base_x               # 初期位置 X座標


  attr_accessor   :base_y               # 初期位置 Y座標


  attr_accessor   :base_h               # 初期位置 高さ座標


  attr_accessor   :max_pattern_w        # セルの横分割数


  attr_accessor   :max_pattern_h        # セルの縦分割数


 


  attr_reader     :collapse             # コラプスフラグ


  attr_reader     :picture              # ピクチャ表示フラグ


  #--------------------------------------------------------------------------


  # ● オブジェクト初期化


  #--------------------------------------------------------------------------


  def initialize(battler)


    @battler = battler


    reset


  end


  #--------------------------------------------------------------------------


  # ● 初期化


  #--------------------------------------------------------------------------


  def reset


    @x = 0


    @y = 0


    @z = 0


    @h = 0


    @j = 0


    @c = 0


    @jump = []


    @curve = []


    @ox = 0


    @oy = 0


    @oy_adjust = 0


    @z_plus = 0


    @move_time = 0


    @angle = 0


    @angle_time = 0


    @zoom_x = 1


    @zoom_y = 1


    @zoom_time = 0


    @pattern_w = 0


    @pattern_h = 0


    @sx = 0


    @sy = 0


    @pattern_type = 0


    @pattern_time = 0


    @pattern_rest_time = 0


    @graphic_name = ""


    @graphic_file_index = ""


    @graphic_index = 0


    @cw = 0


    @ch = 0


    @shadow_visible = false


    @weapon_visible = true


 


    @wait = 0


    @weapon_index = []


    @weapon_end = true


    @full_action = []


    @action = []


    @force_action = ""


    @target_battler = []


    @second_targets = []


    @individual_targets = []


    @m_a_targets = []


    @effect_data = []


    @anime_id = []


    @anime_move_id = []


    @opacity = 255


    @opacity_data = []


    @set_damage = false


    @m_a_data = []


    @m_a_starter = []


    @action_end = false


    @damage_anime_data = []


    @anime_no_mirror = false


    @anime_horming = false


    @anime_camera_zoom = false


    @anime_plus_z = true


    @derivation_skill_id = 0


    @immortal = false


    @mirage = []


    @play_data = []


    @balloon_data = []


    @picture = false


    @timing = []


    @timing_targets = []


    @color_set = []


    @color = []


    @change_up = false


    @non_motion = false


    @graphics_change = false


    @hit = []


    @add_state = []


    @collapse = false


    @counter_id = 0


    @reflection_id = 0


    @result_damage = [0,0]


    @active = false


    @anime_off = false


    @command_action = false


 


    @base_x = 0


    @base_y = 0


    @base_z = 0


    @base_h = 0


    @max_pattern_w = 0


    @max_pattern_h = 0


    @pattern_kind = 0


    @pattern_count = 0


    @move_time = 0


    @mirror = false


    @battler.set_graphic(@pre_change_data[0], @pre_change_data[1], @pre_change_data[2], @pre_change_data[3]) if @pre_change_data != nil


    @pre_change_data = nil


  end  


  #--------------------------------------------------------------------------


  # ● セットアップ


  #--------------------------------------------------------------------------


  def setup(bitmap_width, bitmap_height, first_action_flag)


    reset if first_action_flag


    set_data


    set_base_position if !@graphics_change


    set_graphics(bitmap_width, bitmap_height)


    set_target


    setup_graphics_change if @graphics_change


    first_battler_anime_set if first_action_flag


  end  


  #--------------------------------------------------------------------------


  # ● バトラーデータ取得


  #--------------------------------------------------------------------------


  def set_data


    return if @battler == nil


    if @battler.actor?


      @graphic_name = @battler.character_name


      @graphic_index = @battler.character_index


    else


      @graphic_name = @battler.battler_name


      @graphic_index = 0


    end


    @max_pattern_w = max_pattern[0]


    @max_pattern_h = max_pattern[1]


  end


  #--------------------------------------------------------------------------


  # ● ベース座標をセット data = [X軸, Y軸, H軸]  moment_set…瞬間配置


  #--------------------------------------------------------------------------


  def set_base_position(moment_set = true)


    mirroring_reset


    if @battler.actor?


      data = N03::ACTOR_POSITION[@battler.index].dup


      @base_x = data[0] * 100 if !@mirror


      @base_x = (Graphics.width - data[0]) * 100 if @mirror


    else


      data = [@battler.screen_x, @battler.screen_y, 0].dup


      @base_x = data[0] * 100 if !$sv_camera.mirror


      @base_x = (Graphics.width - data[0]) * 100 if $sv_camera.mirror


    end


    @base_y = data[1] * 100


    @base_h = data[2] * 100


    @base_z = @y


    return if !moment_set


    @x = @base_x 


    @y = @base_y


    @z = @base_z


  end


  #--------------------------------------------------------------------------


  # ● グラフィックデータ取得


  #--------------------------------------------------------------------------


  def set_graphics(bitmap_width, bitmap_height)


    sign = @graphic_name[/^[\!\$]./]


    if sign && sign.include?('$')


      @cw = bitmap_width / @max_pattern_w


      @ch = bitmap_height / @max_pattern_h


    elsif @max_pattern_w == 1 && @max_pattern_h == 1


      @cw = bitmap_width


      @ch = bitmap_height


    else


      @cw = bitmap_width / (@max_pattern_w * 4)


      @ch = bitmap_height / (@max_pattern_h * 2)


    end


    @ox = @cw / 2


    @oy = @ch


    @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw


    @sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch


  end


  #--------------------------------------------------------------------------


  # ● ターゲットをセット


  #--------------------------------------------------------------------------


  def set_target(target = nil)


    @target_battler = target


    @target_battler = [@battler] if target == nil


    @second_targets = @target_battler


  end


  #--------------------------------------------------------------------------


  # ● 画像変更用のセットアップ


  #--------------------------------------------------------------------------


  def setup_graphics_change


    @graphics_change = false


    @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw


    @sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch


  end  


  #--------------------------------------------------------------------------


  # ● 戦闘開始時の待機アニメ画像データ取得


  #--------------------------------------------------------------------------


  def first_battler_anime_set


    loop do


      update


      break if @action_data == nil


      break if @action_data[0] == "motion"


      break if @action_data[0] == "move" && @action_data[8] != ""


      break if @full_action == []


    end


    start_action(first_action) if @battler.movable?


  end


  #--------------------------------------------------------------------------


  # ● アクション開始


  #--------------------------------------------------------------------------


  def start_action(kind = nil)


    return if @event_fix && $game_troop.interpreter.running?


    # ウェイト中の場合キャンセル


    return @wait -= 1 if @wait > 0 && kind == nil


    action_setup(false) if kind != nil


    set_action(kind)


    @action = kind if @action == nil


    # 行動配列が無い場合は行動終了処理へ移行


    action_terminate if @action == nil


    # 次のアクション決定


    @action_data = N03::ACTION[@action]


    next_action


  end


  #--------------------------------------------------------------------------


  # ● 行動パラメータの初期化


  #--------------------------------------------------------------------------


  def action_setup(reset = true)


    @event_fix = false


    @set_damage = false


    @action_end = false


    @balloon_data = []


    @loop_act = []


    angle_reset if reset


    zoom_reset if reset


    opacity_reset if reset


    @curve = []


    @c = 0


    convert_jump


  end  


  #--------------------------------------------------------------------------


  # ● 行動終了処理


  #--------------------------------------------------------------------------


  def action_terminate


    @mirage = [] if @mirage_end


    mirroring_reset


    @picture = false


    @individual_targets = []


    action_setup if @active


    action_setup(false) if !@active


    # 待機アクションへ移行


    stand_by_action if !@non_motion


    # 戦闘行動のアクティブ権を終了


    next_battler


  end  


  #--------------------------------------------------------------------------


  # ● 新しいアクション内容の決定


  #--------------------------------------------------------------------------


  def set_action(kind = nil)


    full_act = N03::FULLACTION[kind]


    @full_action = full_act.dup if full_act != nil


    @action = @full_action.shift


    # 参照したアクションがフルアクションであれば全体のアクションを統合


    full_act2 = N03::FULLACTION[@action]


    @full_action = full_act2.dup + @full_action if full_act2 != nil


  end


  #--------------------------------------------------------------------------


  # ● 次のアクションへ


  #--------------------------------------------------------------------------


  def next_action


    @wait = 0


    # ショートカット確認


    eval(@action) if @action != nil && @action_data == nil && N03::FULLACTION[@action] == nil


    # ウエイト設定


    @wait = @action.to_i if @wait == 0 && @action_data == nil


    @wait = rand(@wait.abs + 1) if @wait < 0


    # アクション開始


    action_play


  end


  #--------------------------------------------------------------------------


  # ● 待機アクションへ移行


  #--------------------------------------------------------------------------


  def stand_by_action


    # 通常待機に


    stand_by_act = normal


    # HPが1/4でピンチアクションに


    stand_by_act = pinch if @battler.hp <= @battler.mhp / 4


    # ステートチェック


    stand_by_act = state(@battler.states[0].id) if @battler.states[0] != nil && state(@battler.states[0].id) != nil


    # コマンドチェック


    stand_by_act = command if @command_action && command != nil


    set_action(stand_by_act)


    @action = stand_by_act if @action == nil


  end


  #--------------------------------------------------------------------------


  # ● 強制アクション開始


  #--------------------------------------------------------------------------


  def start_force_action


    return if @active


    start_action(@force_action)


    @force_action = ""


  end  


  #--------------------------------------------------------------------------


  # ● アクション追加


  #--------------------------------------------------------------------------


  def add_action(kind)


    @full_action.push(kind)


  end  


  #--------------------------------------------------------------------------


  # ● アクションの挿入


  #--------------------------------------------------------------------------


  def unshift_action(kind)


    @full_action.unshift(kind)


  end  


  #--------------------------------------------------------------------------


  # ● フレーム更新


  #--------------------------------------------------------------------------


  def update


    # アクション開始


    start_action


    # 強制アクション開始


    start_force_action if @force_action != ""


    # アニメパターン更新


    update_pattern


    # 移動更新


    update_move


    # 回転更新


    update_angle if @angle_time != 0


    # 拡大縮小更新


    update_zoom if @zoom_time != 0


    # 透明度更新


    update_opacity if @opacity_data != []


  end


  #--------------------------------------------------------------------------


  # ● アニメパターン更新


  #--------------------------------------------------------------------------


  def update_pattern


    return @pattern_rest_time -= 1 if @pattern_rest_time != 0


    return if @max_pattern_w == 1 && @max_pattern_h == 1


    @pattern_rest_time = @pattern_time


    # 再生開始・終了セル位置を取得


    if @pattern_kind > 0 # 通常再生中


      @pattern_start = 0


      @pattern_end = @max_pattern_w - 1


    elsif @pattern_kind < 0 # 逆転再生中


      @pattern_start = @max_pattern_w - 1


      @pattern_end = 0


    end


    # 片道の再生が終了


    @pattern_count += 1 if @pattern_w == @pattern_end && @pattern_kind != 0


    # ループ処理


    case @pattern_type.abs


    when  1,3 # 片道


      @pattern_kind =  0 if @pattern_count != 0 && @pattern_type ==  1


      @pattern_kind =  0 if @pattern_count != 0 && @pattern_type == -1


      @pattern_kind =  1 if @pattern_count != 0 && @pattern_type ==  3


      @pattern_kind = -1 if @pattern_count != 0 && @pattern_type == -3


      @pattern_w = @pattern_start - @pattern_kind if @pattern_count != 0 && @pattern_type.abs == 3


      @pattern_count = 0


    when  2,4 # 往復


      @pattern_kind = -1 if @pattern_count == 1 && @pattern_type ==  2


      @pattern_kind =  1 if @pattern_count == 1 && @pattern_type == -2


      @pattern_kind =  0 if @pattern_count == 2 && @pattern_type ==  2


      @pattern_kind =  0 if @pattern_count == 2 && @pattern_type == -2


      @pattern_kind = -1 if @pattern_count == 1 && @pattern_type ==  4


      @pattern_kind =  1 if @pattern_count == 1 && @pattern_type == -4


      @pattern_kind =  1 if @pattern_count == 2 && @pattern_type ==  4


      @pattern_kind = -1 if @pattern_count == 2 && @pattern_type == -4


      @pattern_count = 0 if @pattern_count == 2


    end


    # セル更新


    @pattern_w += 1 * @pattern_kind


    @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw


  end


  #--------------------------------------------------------------------------


  # ● 移動の更新


  #--------------------------------------------------------------------------


  def update_move


    @z = @y / 100 + @z_plus


    return if @move_time == 0


    target_position_set if @horming_move


    @x = (@x * (@move_time - 1) + @target_x) / @move_time


    @y = (@y * (@move_time - 1) + @target_y) / @move_time


    @h = (@h * (@move_time - 1) + @target_h) / @move_time if @move_h != nil


    @c += @curve[@move_time - 1] if @curve[@move_time - 1] != nil


    @j += @jump[@move_time - 1] if @jump[@move_time - 1] != nil


    @move_time -= 1


    convert_jump if @move_time == 0


  end


  #--------------------------------------------------------------------------


  # ● 移動目標の更新


  #--------------------------------------------------------------------------


  def target_position_set


    target_position = N03.get_targets_position(@move_targets, @horming_move)


    @target_x = target_position[0] + @move_x


    @target_y = target_position[1] + @move_y


    @target_h = target_position[2] + @move_h if @move_h != nil


  end  


  #--------------------------------------------------------------------------


  # ● 回転更新


  #--------------------------------------------------------------------------


  def update_angle


    @angle += @angling


    @angle_time -= 1


    return if @angle_time != 0


    return angle_reset if @angle_data[4] == 0


    angling(@angle_data) if @angle_data[4] == 2


  end  


  #--------------------------------------------------------------------------


  # ● 拡大縮小更新


  #--------------------------------------------------------------------------


  def update_zoom


    @zoom_x += @zooming_x


    @zoom_y += @zooming_y


    @zoom_time -= 1


    return if @zoom_time != 0


    return zoom_reset if @zoom_data[4] == 0


    zooming(@zoom_data) if @zoom_data[4] == 2


  end


  #--------------------------------------------------------------------------


  # ● 透明度更新


  #--------------------------------------------------------------------------


  def update_opacity


    @opacity += @opacity_data[2]


    @opacity_data[0] -= 1


    return if @opacity_data[0] != 0


    return if !@opacity_data[5]


    @opacity_data[2] *= -1


    @opacity_data[0] = @opacity_data[1]


  end


  #--------------------------------------------------------------------------


  # ● アクション実行


  #--------------------------------------------------------------------------


  def action_play 


    return if @action_data == nil


    action = @action_data[0]


    # バトラー反転の場合


    return mirroring                    if action == "mirror"


    # 残像の場合


    return mirage_set                   if action == "mirage"


    # 回転の場合  


    return angling                      if action == "angle"


    # 拡大縮小の場合  


    return zooming                      if action == "zoom"


    # 透明度操作の場合  


    return set_opacity                  if action == "opacity"


    # バトラーアニメの場合


    return battler_anime                if action == "motion"


    # 移動の場合


    return move                         if action == "move"


    # 武器アニメの場合


    return weapon_anime([@action_data]) if action == "wp"


    # アニメ飛ばしの場合


    return move_anime                   if action == "m_a"


    # 戦闘シーン通信の場合(コラプス)


    return set_play_data                if action == "collapse" or action == "no_collapse"


    # データベース戦闘アニメ表示の場合  


    return battle_anime                 if action == "anime"


    # カメラワークの場合


    return camera                       if action == "camera"


    # 画面のシェイクの場合


    return shake                        if action == "shake"


    # 画面色調変更の場合


    return color_effect                 if action == "color"


    # トランジションの場合


    return transition                   if action == "ts"


    # ふきだしアニメ表示の場合  


    return balloon_anime                if action == "balloon"


    # ピクチャ表示の場合


    return picture_set                  if action == "pic"


    # ステート操作の場合


    return state_set                    if action == "sta"


    # FPS変更の場合


    return fps                          if action == "fps"


    # バトラー画像変更の場合  


    return graphics_change              if action == "change"


    # スキル派生の場合  


    return derivating_skill             if action == "der"


    # BGM/BGS/SE演奏の場合  


    return sound                        if action == "sound"


    # ムービー再生の場合  


    return movie                        if action == "movie"


    # ゲームスイッチ操作の場合  


    return switches                     if action == "switch"


    # ゲーム変数操作の場合  


    return variable                     if action == "variable"


    # 条件分岐(ゲームスイッチ)の場合


    return nece_1                       if action == "n_1"


    # 条件分岐(ゲーム変数)の場合


    return nece_2                       if action == "n_2"


    # 条件分岐(ステート)の場合


    return nece_3                       if action == "n_3"


    # 条件分岐(スキル)の場合


    return nece_4                       if action == "n_4"


    # 条件分岐(パラメータ)の場合


    return nece_5                       if action == "n_5"


    # 条件分岐(装備)の場合


    return nece_6                       if action == "n_6"


    # 条件分岐(スクリプト)の場合


    return nece_7                       if action == "n_7"


    # セカンドターゲット操作の場合  


    return second_targets_set           if action == "s_t"


    # コモンイベント呼び出しの場合  


    return call_common_event            if action == "common"


    # 戦闘アニメ消去の場合  


    return @anime_off = true            if action == "anime_off"


    # 強制戦闘終了の場合  


    return BattleManager.process_abort  if action == "battle_end"


    # 画面固定の場合  


    return Graphics.freeze              if action == "graphics_freeze"


    # ダメージアニメの場合  


    return damage_anime                 if action == "damage_anime"


    # 武器消去の場合  


    return @weapon_visible = false      if action == "weapon_off"


    # 武器消去解除の場合  


    return @weapon_visible = true       if action == "weapon_on"


    # 待機キャンセルの場合


    return @non_motion = true           if action == "non_motion"


    # 待機キャンセル解除の場合


    return @non_motion = false          if action == "non_motion_cancel"


    # 初期位置変更の場合


    return change_base_position         if action == "change_base_position"


    # 初期位置変更解除の場合


    return set_base_position(false)     if action == "set_base_position"


    # 強制アクションの場合  


    return force_act                    if action == "force_action"


    # 強制アクションの場合 (セカンドターゲット)


    return force_act2                   if action == "force_action2"


    # 個別開始の場合


    return individual_start             if action == "individual_start"


    # 個別終了の場合


    return individual_end               if action == "individual_end"


    # ループ開始の場合


    return loop_start                   if action == "loop_start"


    # ループ終了の場合


    return loop_end                     if action == "loop_end"


    # 自分のみ更新の場合


    return only_action_on               if action == "only_action_on"


    # 自分のみ更新解除の場合


    return only_action_off              if action == "only_action_off"


    # 次の行動者へ移行の場合


    return next_battler                 if action == "next_battler"


    # 画像変更フラグの場合


    return set_change                   if action == "set_change"


    # スクリプト操作の場合   


    return eval(@action_data[0])


  end


  #--------------------------------------------------------------------------


  # ● バトラー反転実行


  #--------------------------------------------------------------------------


  def mirroring


    @mirror = !@mirror


  end  


  #--------------------------------------------------------------------------


  # ● 反転初期化


  #--------------------------------------------------------------------------


  def mirroring_reset


    @mirror = false


    mirroring if !@battler.actor? && N03::ENEMY_MIRROR


    mirroring if $sv_camera.mirror


  end  


  #--------------------------------------------------------------------------


  # ● 残像実行


  #--------------------------------------------------------------------------


  def mirage_set


    @mirage = @action_data.dup


    @mirage_end = @mirage[3]


    @mirage = [] if @mirage[1] == 0


  end  


  #--------------------------------------------------------------------------


  # ● 回転実行


  #--------------------------------------------------------------------------


  def angling(data = @action_data)


    @angle_data = data.dup


    @oy = @ch / 2


    @oy_adjust = @ch * 50


    @angle_time = data[1]


    start_angle = data[2] * N03.mirror_num(@mirror)


    end_angle = data[3] * N03.mirror_num(@mirror)


    # 時間が0以下なら即座に最終角度へ


    @angle_time = 1 if @angle_time <= 0


    # 回転時間から1フレームあたりの角度を出す


    @angling = (end_angle - start_angle) / @angle_time


    # 割り切れない余りを初期角度に


    @angle = (end_angle - start_angle) % @angle_time + start_angle


  end 


  #--------------------------------------------------------------------------


  # ● 回転初期化


  #--------------------------------------------------------------------------


  def angle_reset


    @oy = @ch


    @angle = @angle_time = @oy_adjust = 0


  end  


  #--------------------------------------------------------------------------


  # ● 拡大縮小実行


  #--------------------------------------------------------------------------


  def zooming(data = @action_data)


    @zoom_data = data.dup


    @zoom_time = data[1]


    start_zoom_x = data[2][0]


    start_zoom_y = data[2][1]


    end_zoom_x = data[3][0]


    end_zoom_y = data[3][1]


    # 時間が0以下なら即座に最終サイズへ


    @zoom_time = 1 if @zoom_time <= 0


    # 拡大縮小時間から1フレームあたりの拡大縮小率を出す


    @zooming_x = (end_zoom_x - start_zoom_x) / @zoom_time


    @zooming_y = (end_zoom_y - start_zoom_y) / @zoom_time


    # 開始サイズに


    @zoom_x = start_zoom_x


    @zoom_y = start_zoom_y


  end  


  #--------------------------------------------------------------------------


  # ● 拡大縮小初期化


  #--------------------------------------------------------------------------


  def zoom_reset


    @zoom_x = @zoom_y = 1


    @zoom_time = 0


  end  


  #--------------------------------------------------------------------------


  # ● バトラー透明度操作


  #--------------------------------------------------------------------------


  def set_opacity


    data = @action_data.dup


    @opacity = data[2]


    opacity_move = (data[3] - data[2])/ data[1]


    @opacity_data = [data[1], data[1], opacity_move, data[4], data[5], data[6]]


    @wait = data[1] if data[7]


    @wait *= 2 if data[6] && data[7]


  end 


  #--------------------------------------------------------------------------


  # ● 透明度操作初期化


  #--------------------------------------------------------------------------


  def opacity_reset


    @opacity = 255


    @opacity = 0 if @battler.hidden?


    @opacity_data = []


  end


  #--------------------------------------------------------------------------


  # ● バトラーアニメ実行


  #--------------------------------------------------------------------------


  def battler_anime(anime_data = nil)


    anime_data = @action_data.dup if anime_data == nil


    @graphic_file_index = anime_data[1] if !graphic_fix


    @pattern_h = anime_data[2]


    @pattern_w = anime_data[3]


    @pattern_h = 0 if @max_pattern_w == 1


    @pattern_w = 0 if @max_pattern_h == 1


    @pattern_type = anime_data[4]


    @pattern_time = anime_data[5]


    @pattern_rest_time = anime_data[5]


    @pattern_count = 0


    @pattern_kind = 1


    @pattern_kind = -1 if @pattern_type < 0


    @pattern_kind = 0 if @pattern_type == 0


    @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw


    @sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch


    @z_plus = anime_data[6]


    @wait = set_anime_wait if anime_data[7]


    @shadow_visible = anime_data[8]


    weapon_anime(anime_data)


  end


  #--------------------------------------------------------------------------


  # ● アニメウエイト計算


  #--------------------------------------------------------------------------


  def set_anime_wait


    if @pattern_type > 0


      pattern_time_a = @max_pattern_w - @pattern_w.abs


    elsif @pattern_type < 0


      pattern_time_a = @pattern_w.abs + 1


    else


      return @pattern_time if @pattern_type == 0


    end


    case @pattern_type


    when 1,-1, 3,-3


      return pattern_time_a * @pattern_time 


    when 2,-2, 4,-4


      return pattern_time_a * @pattern_time + (@max_pattern_w - 2) * @pattern_time


    end


  end  


  #--------------------------------------------------------------------------


  # ● 移動実行


  #--------------------------------------------------------------------------


  def move


    @move_targets = N03.get_targets(@action_data[1].abs, @battler)


    return if @move_targets == []


    @move_targets = [@battler] if @action_data[1].abs == 7


    @move_x = @action_data[2] * 100 * N03.mirror_num(@mirror)


    @move_y = @action_data[3] * 100


    @move_h = @action_data[4] * 100 if @action_data[4] != nil


    @move_h = nil if @action_data[4] == nil


    battler_anime(N03::ACTION[@action_data[8]].dup) if N03::ACTION[@action_data[8]] != nil


    @horming_move = true


    @horming_move = false if @action_data[1] < 0 or @action_data[1].abs == 7


    target_position_set


    target_position = [@target_x, @target_y, @target_z]


    distanse_move = @action_data[5] > 0


    @move_time = N03.distanse_calculation(@action_data[5].abs, target_position, [@x, @y, @z], distanse_move)


    @wait = @move_time


    curve


    jump


    @move_time = 1 if @move_time == 0


    @horming_move = false if !@move_targets or @move_targets.include?(@battler)


    update_move if @move_time == 1


  end  


  #--------------------------------------------------------------------------


  # ● カーブ実行 


  #--------------------------------------------------------------------------


  def curve


    @c = 0


    return if @action_data[6] == 0


    @curve = N03.parabola([@action_data[6], -@action_data[6]], @move_time, 100, 4)


  end  


  #--------------------------------------------------------------------------


  # ● ジャンプ実行


  #--------------------------------------------------------------------------


  def jump


    convert_jump


    return if @action_data[7] == [0,0]


    @jump = N03.parabola(@action_data[7].dup, @move_time, 100)


  end  


  #--------------------------------------------------------------------------


  # ● J座標(ジャンプ高度)をH座標に変換


  #--------------------------------------------------------------------------


  def convert_jump


    @h += @j


    @j = 0


    @jump = []


  end  


  #--------------------------------------------------------------------------


  # ● データベース戦闘アニメ実行


  #--------------------------------------------------------------------------


  def battle_anime


    data = @action_data.dup


    targets = N03.get_targets(data[2], @battler)


    return if targets == []


    data[8] = !data[8] if @mirror


    @set_damage           = data[5]


    @damage_anime_data[0] = N03.get_attack_anime_id(data[1], @battler)


    @damage_anime_data[1] = data[8]


    @damage_anime_data[2] = data[7]


    @damage_anime_data[3] = data[6]


    @damage_anime_data[4] = data[9]


    @wait = N03.get_anime_time(@damage_anime_data[0]) - 2 if data[4]


    return if @set_damage


    for target in targets do display_anime(targets, target, data) end


  end


  #--------------------------------------------------------------------------


  # ● 武器アニメ開始


  #--------------------------------------------------------------------------


  def weapon_anime(anime_data)


    @weapon_end = true


    for i in 9...anime_data.size


      set_effect_data(anime_data[i]) if anime_data[i] != ""


    end


  end


  #--------------------------------------------------------------------------


  # ● アニメ飛ばし開始


  #--------------------------------------------------------------------------


  def move_anime


    @m_a_starter = []


    @m_a_targets = []


    starters = N03.get_targets(@action_data[2], @battler)


    targets = N03.get_targets(@action_data[3], @battler)


    return if starters == [] or targets == []


    single_start = true if starters != nil && @action_data[2] < 0


    single_start = true if @action_data[1][0] != 0 && $data_animations[N03.get_attack_anime_id(@action_data[1][0], @battler)].position == 3


    starters = [starters[0]] if single_start


    single_end = true if targets != nil && @action_data[3] < 0


    single_end = true if @action_data[1][1] != 0 && $data_animations[N03.get_attack_anime_id(@action_data[1][1], @battler)].position == 3


    targets = [targets[0]] if single_end


    se_flag = true


    for starter in starters


      for target in targets


        data = @action_data.dup


        data[17] = se_flag


        @effect_data.push(data)


        @m_a_targets.push(target)


        @m_a_starter.push(starter)


        se_flag = false


      end


    end  


  end


  #--------------------------------------------------------------------------


  # ● スプライトセット通信


  #--------------------------------------------------------------------------


  def set_effect_data(data = @action)


    action_data = N03::ACTION[data]


    return if action_data == nil


    @effect_data.push(action_data.dup)


  end


  #--------------------------------------------------------------------------


  # ● 戦闘シーン通信のデータを格納


  #--------------------------------------------------------------------------


  def set_play_data(data = @action_data)


    @play_data = data.dup


  end


  #--------------------------------------------------------------------------


  # ● 戦闘アニメの表示


  #--------------------------------------------------------------------------


  def display_anime(targets, target, data)


    return if !N03.first_of_all_screen_anime(data[1], target, targets)


    target.animation_id         = N03.get_attack_anime_id(data[1], @battler)


    target.animation_mirror     = data[8]


    target.sv.anime_horming     = data[3]


    target.sv.anime_camera_zoom = data[6]


    target.sv.anime_no_mirror   = data[7]


    target.sv.anime_plus_z      = data[9]


  end


  #--------------------------------------------------------------------------


  # ● 戦闘アニメ拡張データの初期化


  #--------------------------------------------------------------------------


  def reset_anime_data


    @anime_no_mirror = false


    @anime_horming = false


    @anime_camera_zoom = false


    @timing_targets = []


    @anime_plus_z = true


  end  


  #--------------------------------------------------------------------------


  # ● カメラワーク


  #--------------------------------------------------------------------------


  def camera


    data = @action_data.dup


    N03.camera(@battler, data)


    @wait = data[4] if data[5]


  end  


  #--------------------------------------------------------------------------


  # ● 画面のシェイク


  #--------------------------------------------------------------------------


  def shake


    data = @action_data.dup


    $sv_camera.shake(data[1], data[2], data[3])


    @wait = data[3] if data[4]


  end 


  #--------------------------------------------------------------------------


  # ● 画面色調変更


  #--------------------------------------------------------------------------


  def color_effect


    case @action_data[1]


    when 0,1,2,3,4,5


      targets = N03.get_targets(@action_data[1], @battler)


    when 6


      screen = true


    when 7


      targets = [@battler] + @target_battler


    when 8


      screen = true


      targets = $game_troop.members + $game_party.battle_members - [@battler]


    when 9


      screen = true


      targets = $game_troop.members + $game_party.battle_members - [@battler] - @target_battler


    when 10


      screen = true


      targets = $game_troop.members + $game_party.battle_members


    end


    return if screen == nil && targets == []


    for target in targets do target.sv.color_set = @action_data[2] end if targets


    @wait = @action_data[2][4] if @action_data[3]


    return if !screen


    $sv_camera.color_set[1] = @action_data[2]


    $sv_camera.color_set[2] = @action_data[2]


  end  


  #--------------------------------------------------------------------------


  # ● トランジション


  #--------------------------------------------------------------------------


  def transition


    $sv_camera.perform_transition(@action_data)


  end  


  #--------------------------------------------------------------------------


  # ● ふきだしアニメ表示 


  #--------------------------------------------------------------------------


  def balloon_anime


    @balloon_data = @action_data.dup


  end  


  #--------------------------------------------------------------------------


  # ● ピクチャ表示


  #--------------------------------------------------------------------------


  def picture_set


    @picture = true


    set_effect_data


  end


  #--------------------------------------------------------------------------


  # ● ステート操作


  #--------------------------------------------------------------------------


  def state_set


    targets = N03.get_targets(@action_data[1], @battler)


    return if targets == []


    case @action_data[2]


    when 1 ; targets = [targets[rand(targets.size)]]


    when 2 ; targets -= @battler if targets.include?(@battler)


    end


    for target in targets


      for id in @action_data[4]


        target.add_state(id) if @action_data[3] == "+"


        target.remove_state(id) if @action_data[3] == "-"


      end


    end


  end 


  #--------------------------------------------------------------------------


  # ● FPS変更


  #--------------------------------------------------------------------------


  def fps


    Graphics.frame_rate = @action_data[1]


    start_action


  end


  #--------------------------------------------------------------------------


  # ● バトラー画像変更の場合


  #--------------------------------------------------------------------------


  def graphics_change


    @graphics_change = true


    return @battler.graphics_change(@action_data[3]) if !@battler.actor?


    @pre_change_data = [@battler.character_name, @battler.character_index, @battler.face_name, @battler.face_index] if @pre_change_data == nil && !@action_data[1]


    if @action_data[4] == []


      face_name = @battler.face_name


      face_index = @battler.face_index


    else


      face_name = @action_data[4][1]


      face_index = @action_data[4][0]


    end


    @battler.set_graphic(@action_data[3], @action_data[2], face_name, face_index)


  end 


  #--------------------------------------------------------------------------


  # ● スキル派生 


  #--------------------------------------------------------------------------


  def derivating_skill


    # 未修得スキルは派生不可なら


    return if !@action_data[1] && !@battler.skill_learn?($data_skills[@action_data[3]])


    # コスト不足は派生不可なら


    return if !@action_data[2] && !@battler.skill_cost_payable?($data_skills[@action_data[3]])


    # 派生


    @derivation_skill_id = @action_data[3]


    # 以降のアクションをキャンセル


    @full_action = []


  end


  #--------------------------------------------------------------------------


  # ● BGM/BGS/SE演奏


  #--------------------------------------------------------------------------


  def sound


    pitch = @action_data[2] 


    vol   = @action_data[3]


    name  = @action_data[4] 


    case @action_data[1]


    when "se"


      Audio.se_play("Audio/SE/" + name, vol, pitch)


    when "bgm"


      # 名前指定のない場合、現在のBGMを変えないように


      name = RPG::BGM.last.name if @action_data[4] == ""


      Audio.bgm_play("Audio/BGM/" + name, vol, pitch)


    when "bgs"


      name = RPG::BGS.last.name if @action_data[4] == ""


      Audio.bgs_play("Audio/BGS/" + name, vol, pitch)


    end


  end


  #--------------------------------------------------------------------------


  # ● ムービーの再生


  #--------------------------------------------------------------------------


  def movie


    Graphics.play_movie('Movies/' + @action_data[1])


  end


  #--------------------------------------------------------------------------


  # ● ゲームスイッチ操作


  #--------------------------------------------------------------------------


  def switches


    for id in @action_data[1]


      $game_switches[id] = true if id > 0


      $sv_camera.switches[id.abs] = true  if id < 0


    end


    for id in @action_data[2]


      $game_switches[id] = false if id > 0


      $sv_camera.switches[id.abs] = false  if id < 0


    end


    $sv_camera.program_check


  end


  #--------------------------------------------------------------------------


  # ● ゲーム変数操作


  #--------------------------------------------------------------------------


  def variable


    # オペランドチェック


    operand = @action_data[3]


    operand = $game_variables[@action_data[3].abs] if @action_data[3] < 0


    # 変数操作で分岐


    case @action_data[2]


    when 0 ; $game_variables[@action_data[1]] = operand  # 代入


    when 1 ; $game_variables[@action_data[1]] += operand # 加算


    when 2 ; $game_variables[@action_data[1]] -= operand # 減算


    when 3 ; $game_variables[@action_data[1]] *= operand # 乗算


    when 4 ; $game_variables[@action_data[1]] /= operand # 除算


    when 5 ; $game_variables[@action_data[1]] %= operand # 剰余


    end


  end  


  #--------------------------------------------------------------------------


  # ● 条件分岐 (ゲームスイッチ)


  #--------------------------------------------------------------------------


  def nece_1


    judgment = $game_switches[@action_data[1]] == @action_data[2] if @action_data[1] > 0


    judgment = $sv_camera.switches[@action_data[1].abs] == @action_data[2] if @action_data[1] < 0


    action_diverging(judgment, @action_data[3])


  end  


  #--------------------------------------------------------------------------


  # ● 条件分岐 (ゲーム変数)


  #--------------------------------------------------------------------------


  def nece_2


    variable = $game_variables[@action_data[1]]


    num = @action_data[2]


    num = $game_variables[@action_data[2].abs] if num < 0


    case @action_data[3]


    when 0 ; judgment = variable == num


    when 1 ; judgment = variable < num


    when 2 ; judgment = variable > num


    end  


    action_diverging(judgment, @action_data[4])


  end  


  #--------------------------------------------------------------------------


  # ● 条件分岐 (ステート)


  #--------------------------------------------------------------------------


  def nece_3


    targets = N03.get_targets(@action_data[1], @battler)


    return if targets == []


    member_num = @action_data[4]


    member_num = targets.size if @action_data[4] == 0 && targets.size > 1


    hit_count = 0


    miss_count = 0


    for target in targets


      hit_count += 1 if target.state?(@action_data[2])


      miss_count += 1 if !target.state?(@action_data[2])


    end


    case @action_data[3]


    when 0 ; judgment = hit_count >= member_num


    when 1 ; judgment = miss_count >= member_num


    end


    action_diverging(judgment, @action_data[5])


  end  


  #--------------------------------------------------------------------------


  # ● 条件分岐 (スキル)


  #--------------------------------------------------------------------------


  def nece_4


    targets = N03.get_targets(@action_data[1], @battler)


    return if targets == []


    member_num = @action_data[4]


    member_num = targets.size if @action_data[4] == 0 && targets.size > 1


    hit_count = 0


    miss_count = 0


    for target in targets


      hit_count += 1 if target.skill_learn?($data_skills[@action_data[2]]) && target.skill_conditions_met?($data_skills[@action_data[2]])


      miss_count += 1 if !target.skill_learn?($data_skills[@action_data[2]]) or !target.skill_conditions_met?($data_skills[@action_data[2]])


    end


    case @action_data[3]


    when 0 ; judgment = hit_count >= member_num


    when 1 ; judgment = miss_count >= member_num


    end


    action_diverging(judgment, @action_data[5])


  end  


  #--------------------------------------------------------------------------


  # ● 条件分岐 (パラメータ)


  #--------------------------------------------------------------------------


  def nece_5


    targets = N03.get_targets(@action_data[1], @battler)


    return if targets == []


    member_num = @action_data[5]


    member_num = targets.size if @action_data[5] == 0 && targets.size > 1


    hit_count = 0


    for target in targets


      hit_count += 1 if target.comparison_parameter([@action_data[2],@action_data[3],@action_data[4]])


    end


    judgment = hit_count >= member_num


    action_diverging(judgment, @action_data[6])


  end  


  #--------------------------------------------------------------------------


  # ● 条件分岐 (装備)


  #--------------------------------------------------------------------------


  def nece_6


    targets = N03.get_targets(@action_data[1], @battler)


    return if targets == []


    member_num = @action_data[5]


    member_num = targets.size if @action_data[5] == 0 && targets.size > 1


    hit_count = 0


    miss_count = 0


    for target in targets


      hit_count += 1 if target.comparison_equip([@action_data[2],@action_data[3]])


      miss_count += 1 if !target.comparison_equip([@action_data[2],@action_data[3]])


    end


    case @action_data[4]


    when 0 ; judgment = hit_count >= member_num


    when 1 ; judgment = miss_count >= member_num


    end


    action_diverging(judgment, @action_data[6])


  end  


  #--------------------------------------------------------------------------


  # ● 条件分岐 (スクリプト)


  #--------------------------------------------------------------------------


  def nece_7


    judgment = eval(@action_data[2])


    action_diverging(judgment, @action_data[1])


  end  


  #--------------------------------------------------------------------------


  # ● アクション分岐  


  #--------------------------------------------------------------------------


  def action_diverging(judgment, kind)


    result = 0


    if judgment


      result = 1 if kind == 1


      result = 2 if kind == 2


    else


      result = 1 if kind == 0


    end


    # ﾌﾙｱｸｼｮﾝ終了


    return @full_action = []  if result == 2


    # 次のｱｸｼｮﾝを除去


    @full_action.shift if result == 1


    set_action


    # 次のｱｸｼｮﾝを実行


    @action_data = N03::ACTION[@action]


    next_action


  end


  #--------------------------------------------------------------------------


  # ● セカンドターゲット操作


  #--------------------------------------------------------------------------


  def second_targets_set


    targets = N03.get_targets(@action_data[1], @battler)


    for target in targets


      targets.delete(target) if @action_data[2][1] == 1 && target.index != @action_data[2][0]


      targets.delete(target) if @action_data[2][1] == 2 && target.index == @action_data[2][0].abs


      targets.delete(target) if @action_data[3] > 0 && target.id != @action_data[3]


      targets.delete(target) if @action_data[3] < 0 && target.id == @action_data[3].abs


      targets.delete(target) if @action_data[4] > 0 && !target.state?(@action_data[4])


      targets.delete(target) if @action_data[4] < 0 && target.state?(@action_data[4].abs)


      targets.delete(target) if @action_data[5] > 0 && !target.skill_conditions_met?($data_skills[@action_data[5]])


      targets.delete(target) if @action_data[5] < 0 && target.skill_conditions_met?($data_skills[@action_data[5].abs])


      targets.delete(target) if !target.comparison_parameter(@action_data[6])


      targets.delete(target) if !@action_data[7][1].include?(0) && !target.comparison_equip(@action_data[7])


    end


    return @second_targets = [] if targets.size == 0


    case @action_data[8]


    when 1 ; targets = [targets[rand(targets.size)]]


    when 2 ; targets.delete(@battler)


    end


    return @second_targets = [] if targets.size == 0


    @second_targets = targets


    case @action_data[9]


    when 0 ; return


    when 1 ; set_play_data(["second_targets_set"])


    when 2 ; set_play_data(["targets_set"])


    end


    @wait += 1


  end


  #--------------------------------------------------------------------------


  # ● コモンイベント呼び出し


  #--------------------------------------------------------------------------


  def call_common_event


    $game_temp.reserve_common_event(@action_data[1])


    $sv_camera.event = true


    @event_fix = @action_data[2]


  end


  #--------------------------------------------------------------------------


  # ● ダメージアニメ


  #--------------------------------------------------------------------------


  def damage_anime(delay_time = 12)


    anime(N03.get_attack_anime_id(-3, @battler), wait = true)


    action_play


    @wait -= delay_time


    @full_action.unshift("eval('@damage_anime_data = []


    @set_damage = true')")


  end


  #--------------------------------------------------------------------------


  # ● 通常コラプス


  #--------------------------------------------------------------------------


  def normal_collapse


    @collapse = true


    return


  end


  #--------------------------------------------------------------------------


  # ● 初期位置変更


  #--------------------------------------------------------------------------


  def change_base_position


    @base_x = @x


    @base_y = @y


    @base_h = @h


  end  


  #--------------------------------------------------------------------------


  # ● 強制アクション実行


  #--------------------------------------------------------------------------


  def force_act


    target(@full_action.shift)


  end


  #--------------------------------------------------------------------------


  # ● 強制アクション実行 (セカンドターゲット)


  #--------------------------------------------------------------------------


  def force_act2


    target2(@full_action.shift)


  end


  #--------------------------------------------------------------------------


  # ● 個別処理開始


  #--------------------------------------------------------------------------


  def individual_start


    @individual_targets = @target_battler.dup


    @remain_targets = @target_battler.dup


    @target_battler = [@individual_targets[0]]


    # リピート部分のアクションを保持


    @individual_act = @full_action.dup


  end


  #--------------------------------------------------------------------------


  # ● 個別処理終了


  #--------------------------------------------------------------------------


  def individual_end


    @individual_targets.shift


    for target in @individual_targets


      @individual_targets.shift if target.dead?


    end


    # ターゲットが残っているなら行動リピート


    return @target_battler = @remain_targets if @individual_targets.size == 0


    @full_action = @individual_act.dup


    @target_battler = [@individual_targets[0]]


  end


  #--------------------------------------------------------------------------


  # ● ループ開始


  #--------------------------------------------------------------------------


  def loop_start


    # ループ部分のアクションを保持


    @loop_act = @full_action.dup


  end


  #--------------------------------------------------------------------------


  # ● ループ終了


  #--------------------------------------------------------------------------


  def loop_end


    # 行動リピート


    @full_action = @loop_act.dup if @loop_act != []


  end


  #--------------------------------------------------------------------------


  # ● 次の行動者へ移行


  #--------------------------------------------------------------------------


  def next_battler


    @action_end = true


    @active = false


  end


  #--------------------------------------------------------------------------


  # ● 画像変更フラグ


  #--------------------------------------------------------------------------


  def set_change


    @change_up = true


  end


  #--------------------------------------------------------------------------


  # ● 戦闘シーン通信


  #--------------------------------------------------------------------------


  def play_data


    data = @play_data


    @play_data = []


    return data


  end


  #--------------------------------------------------------------------------


  # ● ショートカットコマンド


  #--------------------------------------------------------------------------


  def anime(anime_id, wait = true)


    @action_data = ["anime",anime_id,1,false,wait,false,true,false]


  end


  def anime_me(anime_id, wait = true)


    @action_data = ["anime",anime_id,0,false,wait,false,true,false]


  end


  def se(file, pitch = 100)


    @action_data = ["sound",  "se", pitch, 100, file]


  end


  def target(act)


    for target in @target_battler do target.sv.force_action = act end


  end


  def target2(act)


    for target in @second_targets do target.sv.force_action = act end


  end


  def delay(time)


    @wait = @battler.index * time


  end


  #--------------------------------------------------------------------------


  # ● バトラーのIDを取得


  #--------------------------------------------------------------------------


  def id


    return @battler.id if @battler.actor?


    return -@battler.id


  end


  #--------------------------------------------------------------------------


  # ● 被クリティカルフラグを取得


  #--------------------------------------------------------------------------


  def critical?


    return @battler.result.critical


  end


  #--------------------------------------------------------------------------


  # ● 被回復フラグを取得


  #--------------------------------------------------------------------------


  def recovery?


    recovery = false


    recovery = true if @battler.result.hp_damage < 0


    recovery = true if @battler.result.mp_damage < 0


    recovery = true if @battler.result.tp_damage < 0


    return recovery


  end


  #--------------------------------------------------------------------------


  # ● 被スキルIDを取得


  #--------------------------------------------------------------------------


  def damage_skill_id


    return @damage_skill_id


  end


  #--------------------------------------------------------------------------


  # ● 被アイテムIDを取得


  #--------------------------------------------------------------------------


  def damage_item_id


    return @damage_item_id


  end


  #--------------------------------------------------------------------------


  # ● 装備武器を取得


  #--------------------------------------------------------------------------


  def weapon_id


    return 0 if !@battler.weapons[0]


    return @battler.weapons[0].id


  end


  #--------------------------------------------------------------------------


  # ● 装備武器のタイプを取得


  #--------------------------------------------------------------------------


  def weapon_type


    return 0 if !@battler.weapons[0]


    return @battler.weapons[0].wtype_id


  end


  #--------------------------------------------------------------------------


  # ● 盾を装備しているか


  #--------------------------------------------------------------------------


  def shield?


    for armor in @battler.armors do return true if armor != nil && armor.etype_id == 1 end


    return false


  end


  #--------------------------------------------------------------------------


  # ● ダメージがあるか


  #--------------------------------------------------------------------------


  def damage_zero?


    return @battler.result.hp_damage == 0 && @battler.result.mp_damage == 0 && @battler.result.tp_damage == 0


  end


  #--------------------------------------------------------------------------


  # ● スキルIDを取得


  #--------------------------------------------------------------------------


  def skill_id


    return @counter_id if @counter_id != 0


    return 0 if @battler.current_action == nil or @battler.current_action.item == nil


    return 0 if @battler.current_action.item.is_a?(RPG::Item)


    return @battler.current_action.item.id


  end


  #--------------------------------------------------------------------------


  # ● スキルのタイプを取得


  #--------------------------------------------------------------------------


  def skill_type


    return 0 if skill_id == 0


    return $data_skills[skill_id].stype_id


  end


  #--------------------------------------------------------------------------


  # ● スキル名を取得


  #--------------------------------------------------------------------------


  def skill_name


    return "" if skill_id == 0


    return $data_skills[skill_id].name


  end


  #--------------------------------------------------------------------------


  # ● アイテムIDを取得


  #--------------------------------------------------------------------------


  def item_id


    return 0 if @battler.current_action == nil or @battler.current_action.item == nil


    return @battler.current_action.item.id


  end


  #--------------------------------------------------------------------------


  # ● 攻撃アクション


  #--------------------------------------------------------------------------


  def attack_action(item)


    return skill_action if item.is_a?(RPG::Skill)


    return item_action


  end


  #--------------------------------------------------------------------------


  # ● ダメージアクションベース


  #--------------------------------------------------------------------------


  def damage_action_base(item)


    @damage_skill_id = 0


    @damage_item_id = 0


    @damage_skill_id = item.id if item.is_a?(RPG::Skill)


    @damage_item_id = item.id if item.is_a?(RPG::Item)


  end  


  #--------------------------------------------------------------------------


  # ● ダメージアクション 


  #--------------------------------------------------------------------------


  def damage_action(attacker, item)


    damage_action_base(item)


    act = damage(attacker)


    return if @active


    start_action(act) if act != nil


  end


  #--------------------------------------------------------------------------


  # ● 回避アクション


  #--------------------------------------------------------------------------


  def evasion_action(attacker, item)


    damage_action_base(item)


    act = evasion(attacker)


    return if @active


    start_action(act) if act != nil


  end


  #--------------------------------------------------------------------------


  # ● ミスアクション


  #--------------------------------------------------------------------------


  def miss_action(attacker, item)


    damage_action_base(item)


    act = miss(attacker)


    return if @active


    start_action(act) if act != nil


  end


  #--------------------------------------------------------------------------


  # ● 閃きスクリプト併用処理


  #--------------------------------------------------------------------------


  def flash_action


    return "閃き"


  end


 


end


 


 


#==============================================================================


# ■ module N03


#------------------------------------------------------------------------------


# 　サイドビューバトルのモジュールです。


#==============================================================================


module N03


  #--------------------------------------------------------------------------


  # ● バトラーの敵グループを取得


  #--------------------------------------------------------------------------


  def self.get_enemy_unit(battler)


    return $game_troop if battler.actor?


    return $game_party


  end


  #--------------------------------------------------------------------------


  # ● バトラーの味方グループを取得


  #--------------------------------------------------------------------------


  def self.get_party_unit(battler)


    return $game_party if battler.actor?


    return $game_troop


  end


  #--------------------------------------------------------------------------


  # ● 戦闘アニメ時間の取得


  #--------------------------------------------------------------------------


  def self.get_anime_time(anime_id)


    return 0 if anime_id <= 0


    return $data_animations[anime_id].frame_max * 4


  end


  #--------------------------------------------------------------------------


  # ● 攻撃アニメの取得


  #--------------------------------------------------------------------------


  def self.get_attack_anime_id(kind, battler)


    return $data_skills[battler.sv.counter_id].animation_id if kind == -3 && battler.sv.counter_id != 0


    case kind


    when -1 ; anime_id = battler.atk_animation_id1


    when -2 ; anime_id = battler.atk_animation_id2


    when -3


      if battler.current_action != nil


        anime_id = battler.current_action.item.animation_id if battler.current_action.item != nil


      end


    else    ; anime_id = kind


    end


    case anime_id


    when -1 ; anime_id = battler.atk_animation_id1


    when -2 ; anime_id = battler.atk_animation_id2


    end


    return anime_id if anime_id


    return 0


  end  


  #--------------------------------------------------------------------------


  # ● 戦闘アニメデータをセット


  #--------------------------------------------------------------------------


  def self.set_damage_anime_data(targets, target, data)


    return if !first_of_all_screen_anime(data[0], target, targets)


    target.animation_id         = data[0]


    target.animation_mirror     = data[1]


    target.sv.anime_no_mirror   = data[2]


    target.sv.anime_camera_zoom = data[3]


    target.sv.anime_plus_z      = data[4]


  end    


  #--------------------------------------------------------------------------


  # ● ターゲットの取得 


  #--------------------------------------------------------------------------


  def self.get_targets(kind, battler)


    case kind.abs


    when 0 ; return [battler].dup


    when 1 ; return battler.sv.target_battler.dup


    when 2 ; return get_enemy_unit(battler).members.dup


    when 3 ; return get_party_unit(battler).members.dup


    when 4 ; return $game_troop.members.dup + $game_party.battle_members.dup


    when 5 ; return battler.sv.second_targets.dup


    end


  end  


  #--------------------------------------------------------------------------


  # ● ターゲットの座標を取得


  #--------------------------------------------------------------------------


  def self.get_targets_position(targets, horming, m_a = nil)


    return [0,0,0] if targets == nil && !$sv_camera.mirror


    return [Graphics.width,0,0] if targets == nil && $sv_camera.mirror


    x = y = h = 0


    for i in 0...targets.size


      x += targets[i].sv.base_x if !horming


      y += targets[i].sv.base_y if !horming


      h += targets[i].sv.base_h if !horming


      x += targets[i].sv.x if horming


      y += targets[i].sv.y if horming


      h += targets[i].sv.h if horming


      y -= targets[i].sv.ch * 100 if m_a == 0


      y -= targets[i].sv.ch * 50 if m_a == 1


    end


    return [x / targets.size, y / targets.size, h / targets.size]


  end


  #--------------------------------------------------------------------------


  # ● 速度を時間に変換


  #--------------------------------------------------------------------------


  def self.distanse_calculation(time, target_position, self_position, distanse_move)


    return time if !distanse_move


    distanse_x = self_position[0] - target_position[0]


    distanse_x = target_position[0] - self_position[0] if target_position[0] > self_position[0]


    distanse_y = self_position[1] - target_position[1]


    distanse_y = target_position[1] - self_position[1] if target_position[1] > self_position[1]


    if self_position[2] != nil && target_position[2] != nil


      distanse_h = self_position[2] - target_position[2]


      distanse_h = target_position[2] - self_position[2] if target_position[2] > self_position[2]


    else


      distanse_h = 0


    end


    distanse = [distanse_x, distanse_y, distanse_h].max


    return distanse / (time * 100) + 1


  end


  #--------------------------------------------------------------------------


  # ● 放物線移動計算


  #--------------------------------------------------------------------------


  def self.parabola(data, time, size, type = 1)


    move_data = data


    move_data[0] *= size


    move_data[1] *= size


    move = []


    move_d = []


    for i in 0...time / 2


      move[i] = move_data[0]


      move_d[i] = move_data[1]


      move_data[0] = move_data[0] * type / (1 + type)


      move_data[1] = move_data[1] * type / (1 + type)


    end


    move = move + move_d.reverse!


    move.reverse!


    adjust = move.inject(0) {|result, item| result + item }


    move[move.size - 1] += adjust if data[0] == data[1] && adjust != 0


    move.unshift(0) if time % 2 != 0


    return move


  end


  #--------------------------------------------------------------------------


  # ● 反転値


  #--------------------------------------------------------------------------


  def self.mirror_num(mirror)


    return 1 if !mirror


    return -1


  end  


  #--------------------------------------------------------------------------


  # ● カメラワーク


  #--------------------------------------------------------------------------


  def self.camera(battler, data)


    battler = $game_party.battle_members[0] if !battler


    cx = data[2][0] * 100


    cy = data[2][1] * 100


    return $sv_camera.move(cx, cy, data[3], data[4], true) if data[1] == 6


    targets = self.get_targets(data[1], battler)


    return if targets == nil or targets == []


    position = self.get_targets_position(targets, true)


    $sv_camera.move(position[0], position[1] - position[2], data[3], data[4], false)


  end


  #--------------------------------------------------------------------------


  # ● コラプス禁止


  #--------------------------------------------------------------------------


  def self.immortaling


    # 全員に不死身付与


    for member in $game_party.battle_members + $game_troop.members


      # イベント操作等で不死身設定になっていたら解除を無効にするフラグを立てる


      member.sv.immortal = true if member.state?(N03::IMMORTAL_ID)


      member.add_state(N03::IMMORTAL_ID)


    end


    return true


  end  


  #--------------------------------------------------------------------------


  # ● コラプス許可


  #--------------------------------------------------------------------------


  def self.unimmortaling


    # 全員の不死身化解除(イベント等で不死身設定がされていれば除く)


    for member in $game_party.battle_members + $game_troop.members


      next if member.dead?


      # 不死身ステートが行動中に解除されていた場合、解除無効を解除


      member.sv.immortal = false if !member.state?(N03::IMMORTAL_ID) && member.sv.immortal


      next member.sv.immortal = false if member.sv.immortal


      member.remove_state(N03::IMMORTAL_ID)


      next if member.hp != 0


      member.add_state(1)


      member.perform_collapse_effect


      member.sv.action_terminate


    end


    return false


  end  


  #--------------------------------------------------------------------------


  # ● スキル派生


  #--------------------------------------------------------------------------


  def self.derived_skill(battler)


    battler.force_action(battler.sv.derivation_skill_id, -2)


    BattleManager.unshift_action_battlers(battler)


  end


  #--------------------------------------------------------------------------


  # ● ダメージの作成


  #--------------------------------------------------------------------------


  def self.set_damage(battler, hp_damage, mp_damage)


    battler.result.hp_damage = hp_damage


    battler.result.mp_damage = mp_damage


  end


  #--------------------------------------------------------------------------


  # ● ターゲット生死確認


  #--------------------------------------------------------------------------


  def self.targets_alive?(targets)


    return false if targets == []


    for target in targets do return true if !target.dead? end


    return false


  end


  #--------------------------------------------------------------------------


  # ● ターゲットをセカンドターゲットへ


  #--------------------------------------------------------------------------


  def self.s_targets(battler)


    battler.sv.target_battler = battler.sv.second_targets


    return battler.sv.second_targets


  end  


  #--------------------------------------------------------------------------


  # ● セカンドターゲットをターゲットへ


  #--------------------------------------------------------------------------


  def self.targets_set(battler)


    battler.sv.second_targets = battler.current_action.make_targets.compact


    battler.sv.target_battler = battler.sv.second_targets


  end  


  #--------------------------------------------------------------------------


  # ● 戦闘アニメ実行判定 (対象：画面時は最初のターゲットのみアニメ実行)


  #--------------------------------------------------------------------------


  def self.first_of_all_screen_anime(anime_id, target, targets)


    anime = $data_animations[anime_id]


    return false if !anime


    return true if anime.position != 3


    return false if anime.position == 3 && target != targets[0]


    targets.delete(target)


    target.sv.timing_targets = targets


    return true


  end


  #--------------------------------------------------------------------------


  # ● 戦闘不能付加攻撃か


  #--------------------------------------------------------------------------


  def self.dead_attack?(battler, item)


    for state in battler.atk_states


      return true if state == battler.death_state_id


    end


    for effect in item.effects


      return true if effect.code == 21 && effect.data_id == battler.death_state_id


    end


    return false


  end


end


 


#==============================================================================


# ■ Sprite_Weapon


#------------------------------------------------------------------------------


# 　ウエポン表示用のスプライトです。


#==============================================================================


class Sprite_Weapon < Sprite_Base


  #--------------------------------------------------------------------------


  # ● 公開インスタンス変数　


  #--------------------------------------------------------------------------


  attr_reader   :index                       # ウエポン画像配列のインデックス


  attr_reader   :battler                     # 画像が参照しているバトラー


  attr_reader   :move_time                   # 画像が目標に到達するまでの時間


  attr_reader   :through                     # 貫通フラグ


  attr_reader   :action_end                  # 武器アクション終了フラグ


  attr_reader   :action_end_cancel                  # 武器アクション終了フラグ


  attr_reader   :hit_position                # 画像が目標に到達した時の座標


  attr_accessor :hit_anime_id                # 画像が目標に到達した時のアニメID


  #--------------------------------------------------------------------------


  # ● オブジェクト初期化 


  #--------------------------------------------------------------------------


  def initialize(viewport, index, battler)


    super(viewport)


    @index = index


    @battler = battler


    @position_x = @position_y = 0


    @o = 0


    @real_x = @real_y = 0


    @mirror = @battler.sv.mirror


    reset


    set_action


  end


  #--------------------------------------------------------------------------


  # ● 初期化


  #--------------------------------------------------------------------------


  def reset


    @z_plus = 0


    @weapon_data = []


    @move_data = []


    @move_x = 0


    @move_y = 0


    @orbit = []


    @through = false


    @distanse_move = false


    @weapon_width = 0


    @weapon_height = 0


    @anime_time = 0


    @anime_position = 1


    @move_time = 0


    @hit_anime_id = 0


    @move_anime = true


    @action_end = false


    @action_end_cancel = false


    reset_position


  end  


  #--------------------------------------------------------------------------


  # ● アクションをセット


  #--------------------------------------------------------------------------


  def set_action


    return if @battler.sv.effect_data == []


    weapon_anime if @battler.sv.effect_data[0][0] == "wp"


    move_anime if @battler.sv.effect_data[0][0] == "m_a"


    @battler.sv.effect_data.shift


  end


  #--------------------------------------------------------------------------


  # ● 武器アニメ実行


  #--------------------------------------------------------------------------


  def weapon_anime


    @weapon_data = @battler.sv.effect_data[0].dup


    set_graphics


    set_ox


    set_weapon_move


  end


  #--------------------------------------------------------------------------


  # ● アニメ移動実行


  #--------------------------------------------------------------------------


  def move_anime


    @move_data = @battler.sv.effect_data[0].dup


    # ターゲットを取得


    @target_battler = [@battler.sv.m_a_targets.shift]


    @target_battler = N03.get_targets(@move_data[3], @battler) if @move_data[3] < 0


    set_move


    return if @move_data[16] == ""


    weapon_data = N03::ACTION[@move_data[16]]


    return if weapon_data == nil


    @weapon_data = weapon_data.dup


    set_graphics


    set_ox


    set_weapon_move


  end


  #--------------------------------------------------------------------------


  # ● 武器画像を取得


  #--------------------------------------------------------------------------  


  def set_graphics


    # 武器に依存しない画像設定がある場合


    if @weapon_data[13] != ""


      self.bitmap = Cache.character(@weapon_data[13]).dup


      @weapon_width = self.bitmap.width


      @weapon_height = self.bitmap.height


      return


    end


    # 武器を取得


    weapon = @battler.weapons[0]


    # 逆手装備を取得


    if @weapon_data[10]


      weapon = nil


      for armor in @battler.armors do break weapon = armor if armor.is_a?(RPG::Armor) && armor.etype_id == 1 end


      weapon = @battler.weapons[1] if !weapon


    end  


    # 武器がなければ処理をキャンセル


    return if weapon == nil


    # インデックスを取得


    file_index = @weapon_data[12]


    # アイコンを利用するなら


    if @weapon_data[1] == 0


      icon_index = weapon.icon_index


      self.bitmap = Cache.system("Iconset" + file_index).dup


      self.src_rect.set(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)


      @weapon_width = @weapon_height = 24


    # 独自画像指定 


    else


      file_name = @battler.sv.weapon_graphic(weapon.id, weapon.wtype_id) if weapon.is_a?(RPG::Weapon)


      file_name = @battler.sv.shield_graphic(weapon.id, weapon.atype_id) if weapon.is_a?(RPG::Armor)


      self.bitmap = Cache.character(file_name + file_index).dup


      @weapon_width = self.bitmap.width


      @weapon_height = self.bitmap.height


      return if @weapon_data[1] == 1


      # 2003仕様の武器アニメ


      @weapon_width /= @battler.sv.max_pattern[0]


    end


  end


  #--------------------------------------------------------------------------


  # ● 画像の原点を取得


  #--------------------------------------------------------------------------  


  def set_ox


    # 反転時は設定を逆に


    if @mirror


      case @weapon_data[6]


      when 1 ; @weapon_data[6] = 2 # 左上→右上に


      when 2 ; @weapon_data[6] = 1 # 右上→左上に


      when 3 ; @weapon_data[6] = 4 # 左下→右下に


      when 4 ; @weapon_data[6] = 3 # 右下→左下に


      end


    end


    # 原点を設定


    case @weapon_data[6]


    when 0 # 中心


      self.ox = @weapon_width / 2


      self.oy = @weapon_height / 2


    when 1 # 左上


      self.ox = 0


      self.oy = 0


    when 2 # 右上


      self.ox = @weapon_width


      self.oy = 0


    when 3 # 左下


      self.ox = 0


      self.oy = @weapon_height


    when 4 # 右下


      self.ox = @weapon_width


      self.oy = @weapon_height


    when 5 # バトラーと同じ


      self.ox = @weapon_width / 2


      self.oy = @weapon_height


    end


  end  


  #--------------------------------------------------------------------------


  # ● バトラーの座標を取得


  #--------------------------------------------------------------------------  


  def set_battler_position


    @position_x = @battler.sv.x + @weapon_data[3][0] * N03.mirror_num(@mirror) * 100


    @position_y = (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.c - @battler.sv.oy_adjust) + @weapon_data[3][1] * 100


    reset_position


  end


  #--------------------------------------------------------------------------


  # ● 座標を初期化


  #--------------------------------------------------------------------------  


  def reset_position


    @real_x = @position_x / 100


    @real_y = @position_y / 100


    @real_zoom_x = 1


    @real_zoom_y = 1


  end


  #--------------------------------------------------------------------------


  # ● 戦闘アニメを表示


  #--------------------------------------------------------------------------  


  def set_animation(anime_id)


    return if $data_animations[anime_id] == nil


    @anime_position = $data_animations[anime_id].position


    @horming = true


    @horming = false if @anime_position == 3


    @anime_camera_zoom = true


    @anime_no_mirror = false


    start_animation($data_animations[anime_id], @mirror)


    timings = $data_animations[anime_id].timings


  end


  #--------------------------------------------------------------------------


  # ● ヒット時の戦闘アニメ実行


  #--------------------------------------------------------------------------  


  def set_hit_animation(position_data, hit_anime_id, target)


    return if $data_animations[hit_anime_id] == nil


    @real_x = position_data[0]


    @real_y = position_data[1]


    @position_x = position_data[0] * 100


    @position_y = position_data[1] * 100


    self.z = position_data[2]


    @z_plus = 1000


    @action_end = false


    @horming = true


    set_animation(hit_anime_id)


    @anime_time = $data_animations[hit_anime_id].frame_max * 4


    @timing_targets = [target]


    @move_time = @hit_anime_id = 0


    @weapon_data = []


  end


  #--------------------------------------------------------------------------


  # ● タイミングバトラー追加


  #--------------------------------------------------------------------------  


  def timing_battler_set(target)


    @timing_targets.push(target)


  end


  #--------------------------------------------------------------------------


  # ● 武器の動きを取得


  #--------------------------------------------------------------------------  


  def set_weapon_move


    # 開始位置を取得


    set_battler_position if @move_time == 0


    @z_plus = 50 if @z_plus == 0 && @weapon_data[9]


    self.z = @battler.sv.z + @z_plus


    # 反転処理


    @mirror = !@mirror if @weapon_data[7]


    self.mirror = @mirror


    # 更新パターンをセット


    set_pattern


    @max_pattern = 2 if @max_pattern == 1


    # 動きを計算


    @weapon_move_data = []


    @weapon_angle_data = []


    @weapon_zoom_data = []


    num = N03.mirror_num(@mirror)


    for i in 0...@max_pattern


      move_data_x = @weapon_data[2][0] * num * 100 * i / (@max_pattern - 1)


      move_data_y = @weapon_data[2][1] * 100 * i / (@max_pattern - 1)


      move_angle = @weapon_data[4] * num + (@weapon_data[5] * num - @weapon_data[4] * num) * i / (@max_pattern - 1)


      move_zoom_x = 1 + (@weapon_data[8][0] - 1) * i / (@max_pattern - 1)


      move_zoom_y = 1 + (@weapon_data[8][1] - 1) * i / (@max_pattern - 1)


      @weapon_move_data.push([move_data_x, move_data_y])


      @weapon_angle_data.push(move_angle)


      @weapon_zoom_data.push([move_zoom_x, move_zoom_y])


    end


  end  


  #--------------------------------------------------------------------------


  # ● 更新パターン


  #--------------------------------------------------------------------------


  def set_pattern


    if @weapon_data[11] == -1


      return @max_pattern = @battler.sv.max_pattern[0] if @battler.sv.pattern_type != 0


      @count = @battler.sv.pattern_time


      @max_count = @battler.sv.pattern_time


      @max_pattern = @battler.sv.max_pattern[0]


      @repeat = false


    else


      @count = @weapon_data[11][0]


      @max_count = @weapon_data[11][0]


      @max_pattern = @weapon_data[11][1]


      @repeat = @weapon_data[11][2]


    end


    @pattern = 0


  end


  #--------------------------------------------------------------------------


  # ● 移動実行


  #--------------------------------------------------------------------------


  def set_move


    # 戦闘アニメを取得


    set_animation(@move_data[1][0]) if $data_animations[@move_data[1][0]] != nil && $data_animations[@move_data[1][0]].position != 3


    @anime_camera_zoom = @move_data[13]


    @loop = @move_data[14]


    @loop = false if @move_data[1][0] == 0


    @anime_no_mirror = @move_data[15]


    @se_flag = @move_data[17]


    # 開始位置を取得


    start_position


    @z_plus = 1000 if @move_data[9]


    # ターゲットバトラー画像にこのアニメのSEとタイミング設定を反映させる


    @timing_targets = @target_battler


    # 座標計算


    @move_x = @move_data[5][0] * 100 * N03.mirror_num(@mirror)


    @move_y = @move_data[5][1] * 100


    # 時間計算か速度計算か


    @distanse_move = true if @move_data[6] > 0


    @move_time = @move_data[6].abs


    # 時間0の場合、アニメが設定されていればアニメ表示時間に合わせる


    if @move_time == 0


      @move_time = $data_animations[@move_data[1][0]].frame_max * 4 if $data_animations[@move_data[1][0]]


      @move_time = 1 if !$data_animations[@move_data[1][0]]


      @distanse_move = false


    end


    # 貫通タイプの場合


    @through = true if @move_data[7] == 1


    @auto_through_flag = false


    @auto_through_flag = true if @move_data[7] == 0


    # ターゲット座標計算


    if @target_battler == nil


      @target_x = @move_x * 100


      @target_x = (Graphics.width - @move_x) * 100 if @mirror


      @target_y = @move_y * 100


    else


      move_data_set


    end


    # ターゲットに到達するまでの時間を計算


    @move_time = distanse_calculation(@move_time, @target_x, @target_y)


    # 円軌道計算


    orbit


    # バトラーのウエイト設定


    @battler.sv.wait = @move_time - 1 if @move_data[10][0]


    @move_horming = @move_data[12]


  end  


  #--------------------------------------------------------------------------


  # ● 速度を時間に変換


  #--------------------------------------------------------------------------


  def distanse_calculation(time, target_x, target_y)


    return time if !@distanse_move


    distanse_x = @position_x - @target_x


    distanse_x = @target_x - @position_x if @target_x > @position_x


    distanse_y = @position_y - @target_y


    distanse_y = @target_y - @position_y if @target_y > @position_y


    distanse = [distanse_x, distanse_y].max


    return distanse / (time * 100) + 1


  end 


  #--------------------------------------------------------------------------


  # ● 移動目標の更新


  #--------------------------------------------------------------------------


  def move_data_set


    return if @target_battler == nil


    position = N03.get_targets_position(@target_battler, true, @anime_position)


    @target_x = position[0] + @move_x


    @target_y = position[1] - position[2] + @move_y


  end 


  #--------------------------------------------------------------------------


  # ● 開始位置を計算


  #--------------------------------------------------------------------------


  def start_position


    starter = [@battler.sv.m_a_starter.shift]


    starter = N03.get_targets(@move_data[2], @battler) if @move_data[2] < 0


    position = [0, 0]


    position = N03.get_targets_position(starter, true, @anime_position) if starter != nil


    @position_x = position[0] + @move_data[4][0] * 100


    @position_y = position[1] + position[2] + @move_data[4][1] * 100


    @position_z = @position_y


  end  


  #--------------------------------------------------------------------------


  # ● 円軌道計算


  #--------------------------------------------------------------------------


  def orbit


    orbit_data = @move_data[8].dup


    orbit_data[0] *= 100


    orbit_data[1] *= 100


    orbit_d = []


    for i in 0...@move_time / 2


      @orbit[i] = orbit_data[0]


      orbit_data[0] /= 2


      orbit_d[i] = orbit_data[1]


      orbit_data[1] /= 2


    end


    @orbit = @orbit + orbit_d.reverse!


    @orbit.reverse!


  end  


  #--------------------------------------------------------------------------


  # ● フレーム更新


  #--------------------------------------------------------------------------


  def update


    update_hit_anime if @anime_time != 0


    update_move if @move_time != 0


    update_weapon_move if @weapon_data != []


    update_position


    update_color


    self.visible = @battler.sv.weapon_visible


    super


  end


  #--------------------------------------------------------------------------


  # ● ヒット時の戦闘アニメ


  #--------------------------------------------------------------------------


  def update_hit_anime


    @anime_time -= 1


    @action_end = true if @anime_time == 0


  end


  #--------------------------------------------------------------------------


  # ● 移動の更新


  #--------------------------------------------------------------------------


  def update_move


    move_data_set if @move_horming && !@hit_position


    through_set(@move_time, @target_x, @target_y) if @move_time == 1 && !@hit_position


    @o += @orbit[@move_time - 1] if @orbit[@move_time - 1] != nil


    @position_x = (@position_x * (@move_time - 1) + @target_x) / @move_time


    @position_y = (@position_y * (@move_time - 1) + @target_y) / @move_time + @o


    reset_position


    set_animation(@move_data[1][0]) if @loop && !animation?


    @move_time -= 1


    return if @move_time != 0


    @action_end = true if !@action_end_cancel


  end


  #--------------------------------------------------------------------------


  # ● 武器の動きを更新


  #--------------------------------------------------------------------------


  def update_weapon_move


    pattern = update_pattern


    set_battler_position if @move_time == 0 && !@action_end_cancel


    @real_x = @position_x / 100 + @weapon_move_data[pattern][0] / 100


    @real_y = @position_y / 100 + @weapon_move_data[pattern][1] / 100


    @real_zoom_x = @weapon_zoom_data[pattern][0]


    @real_zoom_y = @weapon_zoom_data[pattern][1]


    self.angle = @weapon_angle_data[pattern]


    self.src_rect.set(@weapon_width * pattern, 0, @weapon_width, @weapon_height) if @weapon_data[1] == 2


  end


  #--------------------------------------------------------------------------


  # ● パターンを更新


  #--------------------------------------------------------------------------


  def update_pattern


    return @battler.sv.pattern_w if @count == nil


    @count -= 1


    return @pattern if @count != 0


    @count = @max_count


    @pattern += 1


    if !@repeat && @pattern == @max_pattern


      @pattern = @max_pattern - 1


    elsif @pattern == @max_pattern


      @pattern = 0


    end


    return @pattern


  end


  #--------------------------------------------------------------------------


  # ● 座標を更新


  #--------------------------------------------------------------------------


  def update_position


    self.x = (@real_x - $sv_camera.x) * $sv_camera.convert / 1000


    self.y = (@real_y - $sv_camera.y) * $sv_camera.convert / 1000


    self.x += $sv_camera.sx / 100 unless @battler.sv.h != 0 && @weapon_data != []


    self.y += $sv_camera.sy / 100 unless @battler.sv.h != 0 && @weapon_data != []


    self.z = @battler.sv.z + @z_plus - 10


    self.zoom_x = @real_zoom_x * $sv_camera.zoom


    self.zoom_y = @real_zoom_y * $sv_camera.zoom


    self.opacity = @battler.sv.opacity if @battler.sv.opacity_data[4]


  end


  #--------------------------------------------------------------------------


  # ● 貫通の処理


  #--------------------------------------------------------------------------


  def through_set(time, target_x, target_y)


    @hit_anime_id = N03.get_attack_anime_id(@move_data[1][1], @battler)


    @battler.sv.wait = N03.get_anime_time(@hit_anime_id) if @move_data[10][1]


    moving_x = (target_x / 100 - @position_x / 100) / time


    moving_y = (target_y / 100 - @position_y / 100) / time


    goal_x = $sv_camera.max_left - 100 if moving_x < 0


    goal_x = Graphics.width + $sv_camera.max_right + 100 if moving_x > 0


    goal_y = $sv_camera.max_top - 100 if moving_y < 0


    goal_y = Graphics.height + $sv_camera.max_bottom + 100 if moving_y > 0


    if goal_x == nil &&  goal_y == nil


      time = 0 


      reset_position


    else


      time = move_calculation(moving_x, moving_y, goal_x, goal_y)


    end


    target_x = @position_x + moving_x * time * 100


    target_y = @position_y + moving_y * time * 100


    @pre_data = [time, target_x, target_y]


    @battler.sv.m_a_data.push([@move_data[11], @target_battler, @index, @auto_through_flag, []])


    @action_end_cancel = true


    @hit_position = [@real_x, @real_y, self.z]


  end  


  #--------------------------------------------------------------------------


  # ● 到達時間試算


  #--------------------------------------------------------------------------


  def move_calculation(moving_x, moving_y, goal_x, goal_y)


    move_x = @position_x / 100


    move_y = @position_y / 100


    time = 0


    loop do


      move_x += moving_x


      move_y += moving_y


      time += 1


      return time if moving_x < 0 && move_x < goal_x


      return time if moving_x > 0 && move_x > goal_x


      return time if moving_y < 0 && move_y < goal_y


      return time if moving_y > 0 && move_y > goal_y


    end


  end   


  #--------------------------------------------------------------------------


  # ● ミス時に消える処理から貫通処理に変換


  #--------------------------------------------------------------------------


  def through_change


    @action_end_cancel = false


    @through = true


    @move_time = @pre_data[0]


    @target_x = @pre_data[1]


    @target_y = @pre_data[2]


    @pre_data = nil


  end  


  #--------------------------------------------------------------------------


  # ● SE とフラッシュのタイミング処理


  #--------------------------------------------------------------------------


  def animation_process_timing(timing)


    return if !@timing_targets


    se_flag = true


    se_flag = @se_flag if @se_flag != nil


    for target in @timing_targets


      target.sv.timing.push([se_flag, timing.dup])


      se_flag = false if @animation.position == 3


    end  


  end


  #--------------------------------------------------------------------------


  # ● 色調の更新


  #--------------------------------------------------------------------------


  def update_color


    return if @battler.sv.color == []


    self.color.set(@battler.sv.color[0], @battler.sv.color[1], @battler.sv.color[2], @battler.sv.color[3])


  end


  #--------------------------------------------------------------------------


  # ● 解放


  #--------------------------------------------------------------------------


  def dispose


    super


    self.bitmap.dispose if self.bitmap != nil


  end


end 


 


#==============================================================================


# ■ Sprite_Battle_Picture


#------------------------------------------------------------------------------


# 　ピクチャ表示用のスプライトです。


#==============================================================================


class Sprite_Battle_Picture < Sprite


  #--------------------------------------------------------------------------


  # ● 公開インスタンス変数　


  #--------------------------------------------------------------------------


  attr_accessor   :action_end           # 終了フラグ


  #--------------------------------------------------------------------------


  # ● オブジェクト初期化


  #--------------------------------------------------------------------------


  def initialize(viewport = nil)


    super(viewport)


    @action_end = false


    self.ox = 0


  end


  #--------------------------------------------------------------------------


  # ● セット


  #--------------------------------------------------------------------------


  def set(battler)


    @battler = battler


    @data = @battler.sv.effect_data.shift


    @time = @data[4]


    @mirror = $sv_camera.mirror


    @mirror = false if !@data[8]


    self.opacity = @data[6][0]


    @s_x = @data[2][0] if @data[2] != []


    @s_x = Graphics.width - @data[2][0]  if @data[2] != [] && @mirror


    @s_y = @data[2][1] if @data[2] != []


    @e_x = @data[3][0] if @data[3] != []


    @e_x = Graphics.width - @data[3][0] if @data[3] != [] && @mirror


    @e_y = @data[3][1] if @data[3] != []


    @s_x = self.x if @data[2] == []


    @s_y = self.y if @data[2] == []


    @e_x = self.x if @data[3] == []


    @e_y = self.y if @data[3] == []


    self.x = @s_x


    self.y = @s_y


    return @action_end = true if @time == 0


    @move_x = (@e_x * 1.0 - @s_x) / @time


    @move_y = (@e_y * 1.0 - @s_y) / @time


    self.z = @data[5]


    return set_plane(battler) if @data[7] != []


    self.bitmap = Cache.picture(@data[9]) if !bitmap or @data[9] != ""


    return @action_end = true if !bitmap


    self.mirror = @mirror


    self.ox = self.bitmap.width if @mirror


  end


  #--------------------------------------------------------------------------


  # ● プレーン移行


  #--------------------------------------------------------------------------


  def set_plane(battler)


    @viewport = Viewport.new(@data[2][0],@data[2][1],@data[7][0],@data[7][1]) if !@viewport


    viewport = @viewport


    @plane = Plane.new(viewport) if !@plane


    @plane.bitmap = Cache.picture(@data[9]) if !@plane.bitmap or @data[9] != ""


    return @action_end = true if !@plane.bitmap


    @plane.ox = @data[7][0]


    @plane.oy = @data[7][1]


    @plane.opacity = @data[6][0]


    @move_x = @remain_move[0] if @data[2] == @data[3]


    @move_y = @remain_move[1] if @data[2] == @data[3]


    @remain_move = [@move_x, @move_y]


  end


  #--------------------------------------------------------------------------


  # ● フレーム更新


  #--------------------------------------------------------------------------


  def update


    @action_end = true if !@battler.sv.picture


    return if @time == 0


    return if @action_end


    @time -= 1


    return plane_update if @plane


    super


    self.x += @move_x


    self.y += @move_y


    self.opacity += @data[6][1]


    return if @time != 1


    self.x = @e_x


    self.y = @e_y


    @time = 0


  end


  #--------------------------------------------------------------------------


  # ● フレーム更新


  #--------------------------------------------------------------------------


  def plane_update


    @plane.ox += @move_x


    @plane.oy += @move_y


    @plane.opacity += @data[6][1]


    @time = @data[4] if @time == 0


  end


  #--------------------------------------------------------------------------


  # ● 解放


  #--------------------------------------------------------------------------


  def dispose


    bitmap.dispose if bitmap


    @plane.dispose if @plane


    @viewport.dispose if @viewport


    super


  end


end


 


#==============================================================================


# ■ Sprite_Back_Picture


#------------------------------------------------------------------------------


# 　周期ピクチャ用のスプライトです。


#==============================================================================


class Sprite_Back_Picture < Plane


  #--------------------------------------------------------------------------


  # ● 公開インスタンス変数　


  #--------------------------------------------------------------------------


  attr_accessor   :action_end           # 終了フラグ


  #--------------------------------------------------------------------------


  # ● オブジェクト初期化


  #--------------------------------------------------------------------------


  def initialize(viewport = nil, index)


    super(viewport)


    @index = index


    @real_x = 0


    @real_y = 0


    @real_opacity = 0


    @move_x = 0


    @move_y = 0


    @move_opacity = 0


    @time = 0


    @switche = 0


    @action_end = false


  end


  #--------------------------------------------------------------------------


  # ● セットアップ


  #--------------------------------------------------------------------------


  def setup(data)


    self.bitmap = Cache.picture(data[9])


    self.z = data[6]


    @switche = data[1]


    mirror = $sv_camera.mirror


    mirror = false if !data[8]


    @move_x = data[3][0]


    @move_x *= -1 if mirror


    @move_y = data[3][1]


    @time = data[4]


    @time = -1 if @time == 0


    @real_opacity = (data[5][0] + 1) * 100


    @move_opacity = data[5][1]


    @start_opacity = data[5][0]


    @shake_ok = data[7]


  end


  #--------------------------------------------------------------------------


  # ● フレーム更新


  #--------------------------------------------------------------------------


  def update


    update_picture if @time != 0


    self.ox = $sv_camera.x - @real_x


    self.oy = $sv_camera.y - @real_y


    if @shake_ok


      self.ox -= $sv_camera.sx / 100


      self.oy -= $sv_camera.sy / 100


    end


    self.ox *= $sv_camera.zoom


    self.oy *= $sv_camera.zoom


    self.zoom_x = @zoom_x * $sv_camera.zoom


    self.zoom_y = @zoom_y * $sv_camera.zoom


    self.opacity = @real_opacity / 100


    @move_opacity *= -1 if self.opacity == 255 or self.opacity <= @start_opacity


    @switche


    @action_end = true if @switche > 0 && !$game_switches[@switche]


    @action_end = true if @switche < 0 && !$sv_camera.switches[@switche.abs]


  end


  #--------------------------------------------------------------------------


  # ● ピクチャの更新


  #--------------------------------------------------------------------------


  def update_picture


    @real_x += @move_x / 100


    @real_y += @move_y / 100


    @real_x = 0 if @real_x >= self.bitmap.width or @real_x <= -self.bitmap.width


    @real_y = 0 if @real_y >= self.bitmap.height or @real_y <= -self.bitmap.height


    @zoom_x = 1


    @zoom_y = 1


    @real_opacity += @move_opacity


    @time -= 1


    @time = -1 if @time < -100


  end


end


 


#==============================================================================


# ■ Sprite_Back_Picture


#------------------------------------------------------------------------------


# 　ダメージ表示のスプライトです。


#==============================================================================


class Sprite_Damage < Sprite


  #--------------------------------------------------------------------------


  # ● 公開インスタンス変数　


  #--------------------------------------------------------------------------


  attr_reader   :action_end                  # POP終了フラグ


  #--------------------------------------------------------------------------


  # ● オブジェクト初期化


  #--------------------------------------------------------------------------


  def initialize(viewport = nil, battler)


    super(viewport)


    @battler = battler


    @time = 0


    return @action_end = true if !@battler


    @direction = -1


    @direction *= -1 if @battler.actor?


    @direction *= -1 if $sv_camera.mirror


    set_state


    set_damage


    update


  end 


  #--------------------------------------------------------------------------


  # ● ステート表示


  #--------------------------------------------------------------------------


  def set_state


    return if !N03::STATE_POP


    states = @battler.result.added_state_objects


    states.delete($data_states[@battler.death_state_id]) if @battler.result.hp_damage != 0


    return if states == []


    return if @battler.sv.add_state == @battler.result.added_state_objects


    @battler.sv.add_state = states.dup


    @st = []


    @st_base = []


    for i in 0...states.size


      @st[i] = Sprite.new


      bitmap_state(@st[i], states[i])


      @st_base[i] = []


      @st_base[i][0] = @direction * (-20 + 5 * i) + @battler.sv.x / 100


      @st_base[i][1] = -40 - @state_height * i + (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.oy_adjust)/ 100


      @st[i].z = 1000 + i


      @st[i].opacity = 0


    end


    @time = @pop_time = 80


  end   


  #--------------------------------------------------------------------------


  # ● ステート画像


  #--------------------------------------------------------------------------


  def bitmap_state(state, state_object)


    name = state_object.name


    state.bitmap = Cache.system("Iconset").dup


    state.src_rect.set(state_object.icon_index % 16 * 24, state_object.icon_index / 16 * 24, 24, 24)


    @state_height = 24


  end


  #--------------------------------------------------------------------------


  # ● ダメージ表示


  #--------------------------------------------------------------------------


  def hit_count


    for i in 0...@battler.sv.hit.size


      if @battler.sv.hit[i] == nil


        @hit = i


        return @battler.sv.hit[i] = @hit


      end


    end


    @hit = @battler.sv.hit.size


    @battler.sv.hit.push(@hit)


  end  


  #--------------------------------------------------------------------------


  # ● ダメージ表示


  #--------------------------------------------------------------------------


  def set_damage


    return @action_end = true if !N03::DAMAGE_POP


    damage = @battler.result.hp_damage if @battler.result.hp_damage != 0


    damage = @battler.result.hp_drain  if @battler.result.hp_drain  != 0


    damage = @battler.result.mp_damage if @battler.result.mp_damage != 0


    damage = @battler.result.mp_drain  if @battler.result.mp_drain  != 0


    damage = @battler.result.tp_damage if @battler.result.tp_damage != 0


    if !damage or damage == 0


      @action_end = true if @st == nil


      return # ステートだけPOPする設定を考慮して@action_endは返さない


    end


    hit_count


    #@hit = @battler.sv.hit


    #@battler.sv.hit += 1 if damage != 0


    file = N03::DAMAGE_PLUS if damage > 0


    file = N03::DAMAGE_MINUS if damage < 0


    add_file = N03::DAMAGE_MP if @battler.result.mp_damage != 0


    add_file = N03::DAMAGE_TP if @battler.result.tp_damage != 0


    adjust_x = N03::DAMAGE_ADJUST


    @num = []


    @num_base = []


    damage = damage.abs


    max_num = damage.to_s.size


    max_num += 1 if add_file != nil


    for i in 0...max_num


      @num[i] = Sprite.new


      if add_file != nil && i == max_num - 1


        @num[i].bitmap = Cache.system(add_file)


        cw = (damage % (10 * 10 ** i))/(10 ** i)


        sw = 0 if sw == nil


      else


        @num[i].bitmap = Cache.system(file)


        cw = (damage % (10 * 10 ** i))/(10 ** i)


        sw = @num[i].bitmap.width / 10


        @num[i].src_rect.set(cw * sw, 0, sw, @num[i].bitmap.height)


      end


      @num_base[i] = []


      @num_base[i][0] = (sw + adjust_x) * i * -1 + (@battler.sv.x / 100)


      @num_base[i][1] =  -(@num[i].bitmap.height * 5) - i * 1 - @hit * 2 + (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.oy_adjust)/ 100


      @num_base[i][0] -= @num[i].bitmap.width / 2 - adjust_x if add_file != nil && i == max_num - 1


      @num[i].z = 1000 + i + @hit * 10


    end


    @time = @pop_time = 80


  end


  #--------------------------------------------------------------------------


  # ● フレーム更新


  #--------------------------------------------------------------------------


  def update


    return if @time == 0


    for i in 0...@st.size do update_state_move(@st[i], i) end if @st != nil


    for i in 0...@num.size do update_num_move(@num[i], i) end if @num != nil


    @time -= 1


    @action_end = true if @time == 0


  end


  #--------------------------------------------------------------------------


  # ● ステート画像の更新


  #--------------------------------------------------------------------------


  def update_state_move(state, index)


    min = @pop_time - index * 2


    case @time


    when min-15..min


      @st_base[index][0] += @direction


      state.opacity += 25


    when min-80..min-50


      @st_base[index][0] += @direction


      state.opacity -= 25


    end


    state.x = (@st_base[index][0] - $sv_camera.x) * $sv_camera.zoom


    state.y = (@st_base[index][1] - $sv_camera.y) * $sv_camera.zoom


  end


  #--------------------------------------------------------------------------


  # ● 数値の更新


  #--------------------------------------------------------------------------


  def update_num_move(num, index)


    min = @pop_time - index * 2


    case @time


    when min-1..min


      @num_base[index][0] += @direction * @hit


      @num_base[index][1] -= 5 + @hit * 2


    when min-3..min-2


      @num_base[index][0] += @direction * @hit


      @num_base[index][1] -= 4 + @hit * 2


    when min-6..min-4


      @num_base[index][0] += @direction


      @num_base[index][1] -= 3 + @hit * 2


    when min-14..min-7


      @num_base[index][0] += @direction


      @num_base[index][1] += 2


    when min-17..min-15


      @num_base[index][1] -= 2 + @hit * 2


    when min-23..min-18


      @num_base[index][1] += 1


    when min-27..min-24


      @num_base[index][1] -= 1


    when min-30..min-28


      @num_base[index][1] += 1


    when min-33..min-31


      @num_base[index][1] -= 1


    when min-36..min-34


      @num_base[index][1] += 1


    end


    num.x = (@num_base[index][0] - $sv_camera.x) * $sv_camera.zoom


    num.y = (@num_base[index][1] - $sv_camera.y) * $sv_camera.zoom


    num.opacity = 256 - (12 - @time) * 32


    num.visible = false if @time == 0


  end


  #--------------------------------------------------------------------------


  # ● 解放


  #--------------------------------------------------------------------------


  def dispose


    @battler.sv.hit[@hit] = nil if @hit


    bitmap.dispose if bitmap


    for i in 0...@num.size do @num[i].dispose end if @num != nil


    for i in 0...@st.size do @st[i].dispose end if @st != nil


    super


  end


end


 


#==============================================================================


# ■ Window_Skill_name


#------------------------------------------------------------------------------


# 　スキル名を表示するウィンドウです。


#==============================================================================


class Window_Skill_name < Window_Base


  #--------------------------------------------------------------------------


  # ● オブジェクト初期化


  #--------------------------------------------------------------------------


  def initialize(text)


    super(0, 0, Graphics.width, line_height + standard_padding * 2)


    draw_text(4, 0, Graphics.width - 64, line_height,text, 1)


  end


end


 


#==============================================================================


# ■ Spriteset_Sideview


#------------------------------------------------------------------------------


# 　サイドビュー独自のスプライトをまとめたクラスです。


#==============================================================================


class Spriteset_Sideview


  #--------------------------------------------------------------------------


  # ● オブジェクト初期化


  #--------------------------------------------------------------------------


  def initialize(viewport)


    @viewport = viewport


    @weapons = []


    @pictures = []


    @back_pic = []


    @damage = []


    $sv_camera.setup


    N03.camera(nil, N03::BATTLE_CAMERA["ターン開始前"].dup)


  end


  #--------------------------------------------------------------------------


  # ● フレーム更新


  #--------------------------------------------------------------------------


  def update


    update_battler_data


    update_damage


    update_pictures


    update_back_pic


    update_weapons


  end  


  #--------------------------------------------------------------------------


  # ● バトラーデータの更新


  #--------------------------------------------------------------------------


  def update_battler_data


    for battler in $game_party.battle_members + $game_troop.members


      weapon_end(battler) if battler.sv.weapon_end


      next if battler.sv.effect_data == []


      for effect_data in battler.sv.effect_data do set_effects(battler, effect_data) end


    end


  end


  #--------------------------------------------------------------------------


  # ● ダメージ画像の更新


  #--------------------------------------------------------------------------


  def update_damage


    for i in 0...@damage.size


      next if @damage[i] == nil


      @damage[i].update if @damage[i] != nil


      next if !@damage[i].action_end


      @damage[i].dispose


      @damage[i] = nil


    end


  end


  #--------------------------------------------------------------------------


  # ● ピクチャアクションの更新


  #--------------------------------------------------------------------------


  def update_pictures


    for i in 0...@pictures.size


      next if @pictures[i] == nil


      @pictures[i].update if @pictures[i] != nil


      next if !@pictures[i].action_end


      @pictures[i].dispose


      @pictures[i] = nil


    end


  end


  #--------------------------------------------------------------------------


  # ● 周期ピクチャの更新


  #--------------------------------------------------------------------------


  def update_back_pic


    set_back_pic if $sv_camera.program_picture != []


    for i in 0...@back_pic.size


      next if @back_pic[i] == nil


      @back_pic[i].update if @back_pic[i] != nil


      next if !@back_pic[i].action_end


      @back_pic[i].dispose


      @back_pic[i] = nil


    end


  end


  #--------------------------------------------------------------------------


  # ● 武器アクションの更新


  #--------------------------------------------------------------------------


  def update_weapons


    for i in 0...@weapons.size


      next if @weapons[i] == nil


      @weapons[i].update if @weapons[i] != nil


      next if !@weapons[i].action_end


      @weapons[i].dispose


      @weapons[i] = nil


    end


  end


  #--------------------------------------------------------------------------


  # ● ダメージ実行


  #--------------------------------------------------------------------------


  def set_damage_pop(target)


    for i in 0...@damage.size


      next if @damage[i] != nil


      return @damage[i] = Sprite_Damage.new(@viewport, target)


    end


    @damage.push(Sprite_Damage.new(@viewport, target))


  end


  #--------------------------------------------------------------------------


  # ● 周期ピクチャ実行


  #--------------------------------------------------------------------------


  def set_back_pic


    for data in $sv_camera.program_picture


      if @back_pic[data[2]] != nil


        @back_pic[data[2]].dispose


        @back_pic[data[2]] = nil


      end


      @back_pic[data[2]] = Sprite_Back_Picture.new(@viewport, data[2])


      @back_pic[data[2]].setup(data)


    end


    $sv_camera.program_picture = []


  end


  #--------------------------------------------------------------------------


  # ● エフェクト開始


  #--------------------------------------------------------------------------


  def set_effects(battler, effect_data)


    case effect_data[0]


    when "pic" ; set_pictures(battler, effect_data)


    when  "wp" ; set_weapons(battler,  true)


    when "m_a" ; set_weapons(battler, false)


    end


  end


  #--------------------------------------------------------------------------


  # ● ピクチャアクション実行


  #--------------------------------------------------------------------------


  def set_pictures(battler, effect_data)


    @pictures[effect_data[1]] = Sprite_Battle_Picture.new if @pictures[effect_data[1]] == nil


    @pictures[effect_data[1]].set(battler)


  end


  #--------------------------------------------------------------------------


  # ● 武器アクション実行


  #--------------------------------------------------------------------------


  def set_weapons(battler, weapon_flag, test = true)


    for i in 0...@weapons.size


      next if @weapons[i] != nil


      @weapons[i] = Sprite_Weapon.new(@viewport, i, battler) 


      battler.sv.weapon_index.push(i) if weapon_flag


      return i


    end


    @weapons.push(Sprite_Weapon.new(@viewport, @weapons.size, battler))


    battler.sv.weapon_index.push(@weapons.size - 1) if weapon_flag


    return @weapons.size - 1


  end


  #--------------------------------------------------------------------------


  # ● バトラーの武器アクション終了


  #--------------------------------------------------------------------------


  def weapon_end(battler)


    battler.sv.weapon_end = false


    for index in battler.sv.weapon_index


      weapon_index = battler.sv.weapon_index.shift


      @weapons[weapon_index].dispose if @weapons[weapon_index] != nil


      @weapons[weapon_index] = nil


    end


    battler.sv.weapon_index.compact!


  end  


  #--------------------------------------------------------------------------


  # ● ヒット時の戦闘アニメ実行


  #--------------------------------------------------------------------------


  def set_hit_animation(battler, weapon_index, hit_targets, miss)


    weapon = @weapons[weapon_index]


    for target in hit_targets


      next @weapons[@hit_index].timing_battler_set(target) if @hit_index != nil


      @hit_index = set_weapons(battler, false, false)


      @weapons[@hit_index].set_hit_animation(weapon.hit_position, weapon.hit_anime_id, target)


    end


    @hit_index = nil


    if !weapon.through && !miss


      @weapons[weapon_index].dispose


      @weapons[weapon_index] = nil


    else


      @weapons[weapon_index].through_change


    end


  end


  #--------------------------------------------------------------------------


  # ● サイドビューデータの初期化


  #--------------------------------------------------------------------------


  def reset_sideview


    $sv_camera.reset


    for member in $game_troop.members + $game_party.battle_members do member.sv.reset end


  end  


  #--------------------------------------------------------------------------


  # ● 解放


  #--------------------------------------------------------------------------


  def dispose


    dispose_effects(@weapons)


    dispose_effects(@pictures)


    dispose_effects(@back_pic)


    dispose_effects(@damage)


    reset_sideview


  end


  #--------------------------------------------------------------------------


  # ● エフェクト画像の解放


  #--------------------------------------------------------------------------


  def dispose_effects(effects)


    for i in 0...effects.size


      effects[i].dispose if effects[i] != nil


      effects[i] = nil


    end


  end


end


 


 


#==============================================================================


# ■ Sprite_Battle_Back


#------------------------------------------------------------------------------


# 　戦闘背景用のスプライトです。


#==============================================================================


class Sprite_Battle_Back < Plane


  #--------------------------------------------------------------------------


  # ● オブジェクト初期化


  #--------------------------------------------------------------------------


  def initialize(viewport = nil, index, battleback_name)


    super(viewport)


    @index = index


    if @index == 1


      data = N03::FLOOR1_DATA[battleback_name]


      data = N03::FLOOR1_DATA["全Battlebacks1"] if data == nil


    elsif @index == 2


      data = N03::FLOOR2_DATA[battleback_name]


      data = N03::FLOOR2_DATA["全Battlebacks2"] if data == nil


    end    


    data = data.dup


    @adjust_position = data[0]


    @zoom_x = data[1][0] / 100.0


    @zoom_y = data[1][1] / 100.0


    @shake_on = data[2]


    $game_switches[data[3]] = true if data[3] > 0


    $sv_camera.switches[data[3].abs] = true if data[3] < 0


    reset_scroll


    reset_back_data(battleback_name)


  end


  #--------------------------------------------------------------------------


  # ● 背景スクロールを初期化


  #--------------------------------------------------------------------------


  def reset_scroll


    @scroll_x = 0


    @scroll_y = 0


    @move_x = 0


    @move_y = 0


  end


  #--------------------------------------------------------------------------


  # ● 背景データを初期化


  #--------------------------------------------------------------------------


  def reset_back_data(battleback_name)


    @back_data = []


    @active_data = ["scroll",0, @move_x, @move_y, false, battleback_name,""]


    start_back_data(@active_data)


  end  


  #--------------------------------------------------------------------------


  # ● 背景画像のセッティング


  #--------------------------------------------------------------------------


  def set_graphics(new_bitmap)


    self.bitmap = new_bitmap


    @base_x = (self.bitmap.width * @zoom_x - Graphics.width) / 2 + @adjust_position[0]


    @base_y = (self.bitmap.height * @zoom_y - Graphics.height) / 2 + @adjust_position[1]


    # 限界座標を取得


    max_top =  0


    max_bottom = self.bitmap.height * @zoom_y - Graphics.height


    max_left = 0


    max_right = self.bitmap.width * @zoom_x - Graphics.width


    exist = true 


    exist = false if self.bitmap.height == 32 && self.bitmap.width == 32


    $sv_camera.setting(@index, [max_top, max_bottom, max_left, max_right, @base_x, @base_y,exist])


  end


  #--------------------------------------------------------------------------


  # ● フレーム更新


  #--------------------------------------------------------------------------


  def update


    return if !bitmap


    update_back_data


    update_scroll unless @move_x == 0 && @move_y == 0


    update_color


    update_position


    update_back_adjust if @bt_back != nil


    create_back_adjust if @bt_back == nil && !@active_data[10] && @scroll_x == 0 && @scroll_y == 0


  end


  #--------------------------------------------------------------------------


  # ● 背景データを更新


  #--------------------------------------------------------------------------


  def update_back_data


    delete = true if @active_data[1] > 0 && !$game_switches[@active_data[1]]


    delete = true if @active_data[1] < 0 && !$sv_camera.switches[@active_data[1].abs]


    return if !delete


    for i in 0...@back_data.size


      @back_data[i] = nil if @back_data[i][1] > 0 && !$game_switches[@back_data[i][1]]


      @back_data[i] = nil if @back_data[i][1] < 0 && !$sv_camera.switches[@back_data[i][1].abs]


    end


    @back_data.compact!


    next_back_data


  end


  #--------------------------------------------------------------------------


  # ● 次の背景データをセット


  #--------------------------------------------------------------------------


  def next_back_data


    @back_data.delete(@active_data[11]) if @active_data[11] != nil


    @back_data.push(@active_data[11]) if @active_data[11] != nil


    @active_data = nil


    data = @back_data.pop


    @back_data = [@active_data] if @back_data.size == 0


    start_back_data(data)


  end  


  #--------------------------------------------------------------------------


  # ● 背景データを実行


  #--------------------------------------------------------------------------


  def start_back_data(data)


    return if back_data_remain(data)


    bt_back_dispose


    pre_active_data = @active_data


    @active_data[8] = [@back_name, @move_x, @move_y, @scroll_x, @scroll_y] if @active_data != nil


    @back_data.push(@active_data)     if @active_data != nil


    @active_data = data.dup


    @active_data[5] = @back_name      if @active_data[5] == ""


    @active_data[9] = set_back_adjust if @active_data[9] == nil


    back_data_scroll_on               if @active_data[8] == nil && @active_data[9][0] == false


    set_remain_back_data              if @active_data[8] != nil


    create_back(@active_data[5])      if @active_data[9][0] == false


    create_back_adjust                if @active_data[10]


    @active_data[11] = pre_active_data if pre_active_data && @active_data[7] == false


  end  


  #--------------------------------------------------------------------------


  # ● 背景データの保留


  #--------------------------------------------------------------------------


  def back_data_remain(data)


    remain = false


    remain = true if data[6] != "" && @active_data != nil && @active_data[9] != nil && @active_data[9][0] != false


    remain = true if @active_data != nil && @active_data[7] == false


    return remain if !remain


    @remain = true


    @back_data.push(data)


    return remain


  end  


  #--------------------------------------------------------------------------


  # ● 背景変更補正データをセット


  #--------------------------------------------------------------------------


  def set_back_adjust


    bt_adjust = []


    sign = -1


    if @active_data[6] == ""


      reset_scroll if @active_data[3][0] == 0 &&  @active_data[3][1] == 0


      bt_adjust = [false,false,0,0]


      return bt_adjust


    elsif @move_x != 0 or @active_data[3][0] != 0


      sign = 1 if @move_x < 0


      bt_adjust[0] = [self.bitmap.width * @zoom_x * sign, 0]


      bt_adjust[1] = [self.bitmap.width * @zoom_x * sign * 2, 0]


    elsif @move_y != 0 or @active_data[3][1] != 0


      sign = 1 if @move_y < 0


      bt_adjust[0] = [0, self.bitmap.height * @zoom_y * sign]


      bt_adjust[1] = [0, self.bitmap.height * @zoom_y * sign * 2]


    else


      reset_scroll if @active_data[3][0] == 0 &&  @active_data[3][1] == 0


      bt_adjust = [false,false,0,0]


      return bt_adjust


    end


    bt_adjust[2] = [bt_adjust[0][0], bt_adjust[0][1]]


    return bt_adjust


  end


  #--------------------------------------------------------------------------


  # ● 背景スクロールデータを実行


  #--------------------------------------------------------------------------


  def back_data_scroll_on


    mirror = $sv_camera.mirror


    mirror = false if !@active_data[4]


    @move_x = @active_data[3][0]


    @move_x *= -1 if mirror


    @move_y = @active_data[3][1]


  end


  #--------------------------------------------------------------------------


  # ● 保持している背景データを実行


  #--------------------------------------------------------------------------


  def set_remain_back_data


    return back_data_scroll_on if @move_x != 0 or @move_y != 0


    create_back(@active_data[8][0])


    @move_x    = @active_data[8][1]


    @move_y    = @active_data[8][2]


    @scroll_x  = @active_data[8][3]


    @scroll_y  = @active_data[8][4]


  end  


  #--------------------------------------------------------------------------


  # ● 背景画像の作成


  #--------------------------------------------------------------------------


  def create_back(back_name)


    return if back_name == @back_name or back_name == ""


    self.bitmap = Cache.battleback1(back_name) if @index == 1


    self.bitmap = Cache.battleback2(back_name) if @index == 2


    @back_name = back_name


  end  


  #--------------------------------------------------------------------------


  # ● 背景変更補正画像の作成


  #--------------------------------------------------------------------------


  def create_back_adjust


    return if @active_data[9][0] == false


    @active_data[10] = true


    mirror = $sv_camera.mirror


    mirror = false if !@active_data[4]


    @bt_back = []


    @bt_back[0] = Sprite.new(viewport)


    @bt_back[0].bitmap = Cache.battleback1(@active_data[6]) if @index == 1


    @bt_back[0].bitmap = Cache.battleback2(@active_data[6]) if @index == 2


    @bt_back[0].mirror = mirror


    @bt_back[1] = Sprite.new(viewport)


    @bt_back[1].bitmap = Cache.battleback1(@active_data[5]) if @index == 1


    @bt_back[1].bitmap = Cache.battleback2(@active_data[5]) if @index == 2


    @bt_back[1].mirror = mirror


  end


  #--------------------------------------------------------------------------


  # ● 背景スクロールの更新


  #--------------------------------------------------------------------------


  def update_scroll


    @scroll_x += @move_x


    @scroll_y += @move_y


    @scroll_x = 0 if @scroll_x / 100 >= self.bitmap.width * @zoom_x or @scroll_x / 100 <= -self.bitmap.width * @zoom_x


    @scroll_y = 0 if @scroll_y / 100 >= self.bitmap.height * @zoom_y or @scroll_y / 100 <= -self.bitmap.height * @zoom_y


  end


  #--------------------------------------------------------------------------


  # ● 色調変更の更新


  #--------------------------------------------------------------------------


  def update_color


    color_set if $sv_camera.color_set[@index] != nil


    return if @color_data == nil


    @color_data[4] -= 1


    if @color_data[4] == 0 && @color_data[5] != 0


      @color_data[4] = @color_data[5]


      @color_data[5] = 0


      @color_data[6] = [0,0,0,0]


    elsif @color_data[4] == 0


      @remain_color_data = @color_data


      return @color_data = nil


    end  


    for i in 0..3


      @color_data[i] = (@color_data[i] * (@color_data[4] - 1) + @color_data[6][i]) / @color_data[4]


    end  


    self.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3])


  end


  #--------------------------------------------------------------------------


  # ● 座標の更新


  #--------------------------------------------------------------------------


  def update_position


    self.ox = $sv_camera.x + @base_x - @scroll_x / 100


    self.oy = $sv_camera.y + @base_y - @scroll_y / 100


    self.ox -= $sv_camera.sx / 100 if @shake_on


    self.oy -= $sv_camera.sy / 100 if @shake_on


    self.zoom_x = @zoom_x * $sv_camera.zoom


    self.zoom_y = @zoom_y * $sv_camera.zoom


    self.ox *= $sv_camera.zoom


    self.oy *= $sv_camera.zoom


    self.z = @index * 10


  end


  #--------------------------------------------------------------------------


  # ● 背景変更補正画像を更新


  #--------------------------------------------------------------------------


  def update_back_adjust


    @active_data[9][0][0] = 0 if @scroll_x == 0


    @active_data[9][0][1] = 0 if @scroll_y == 0


    @active_data[9][1][0] -= @active_data[9][2][0] if @scroll_x == 0


    @active_data[9][1][1] -= @active_data[9][2][1] if @scroll_y == 0


    for i in 0...@bt_back.size


      @bt_back[i].x = -self.ox + @active_data[9][i][0] * $sv_camera.zoom


      @bt_back[i].y = -self.oy + @active_data[9][i][1] * $sv_camera.zoom


      @bt_back[i].zoom_x = self.zoom_x


      @bt_back[i].zoom_y = self.zoom_y


      @bt_back[i].z = self.z + 1


      @bt_back[i].color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil


    end


    back_data_scroll_on if @active_data[9][0][0] == 0 && @active_data[9][0][1] == 0


    return unless @active_data[9][1][0] == 0 && @active_data[9][1][1] == 0


    bt_back_dispose


    create_back(@active_data[5])


    @active_data[9][0] = false


    next_back_data if @remain && @back_data.size != 1


    @remain = false


  end


  #--------------------------------------------------------------------------


  # ● 色調変更


  #--------------------------------------------------------------------------


  def color_set


    set = $sv_camera.color_set[@index]


    $sv_camera.color_set[@index] = nil


    set[4] = 1 if set[4] == 0


    @remain_color_data = [0,0,0,0] if @remain_color_data == nil


    @color_data = @remain_color_data


    @color_data[4] = set[4]


    @color_data[5] = set[5]


    @color_data[6] = set


  end


  #--------------------------------------------------------------------------


  # ● 背景変更補正画像の解放


  #--------------------------------------------------------------------------


  def bt_back_dispose


    for i in 0...@bt_back.size do @bt_back[i].dispose end if @bt_back != nil


    @bt_back = nil


  end  


  #--------------------------------------------------------------------------


  # ● 解放


  #--------------------------------------------------------------------------


  def dispose


    bitmap.dispose if bitmap


    bt_back_dispose


    super


  end


end  


 


#==============================================================================


# ■ Battle_Camera


#------------------------------------------------------------------------------


# 　戦闘カメラやバトルプログラムを扱うクラスです。 


#==============================================================================


class Battle_Camera


  #--------------------------------------------------------------------------


  # ● 公開インスタンス変数　


  #--------------------------------------------------------------------------


  attr_reader   :sx                 # シェイクX座標


  attr_reader   :sy                 # シェイクY座標


  attr_reader   :max_top            # 上限界座標


  attr_reader   :max_bottom         # 下限界座標


  attr_reader   :max_left           # 左限界座標


  attr_reader   :max_right          # 右限界座標


  attr_accessor :switches           # サイドビュー専用スイッチ


  attr_accessor :color_set          # 色調変更データ


  attr_accessor :wait               # 戦闘シーンの強制ウエイト


  attr_accessor :win_wait           # 戦闘勝利前のウエイト


  attr_accessor :mirror             # 画面反転フラグ


  attr_accessor :program_scroll     # バトルプログラム 背景の自動スクロール


  attr_accessor :program_picture    # バトルプログラム 周期ピクチャ


  attr_accessor :event              # コモンイベント呼び出し


  #--------------------------------------------------------------------------


  # ● オブジェクト初期化 


  #--------------------------------------------------------------------------


  def initialize


    @switches = []


    @max_data = []


    @color_set = []


    @wait = 0


    @win_wait = false


    @mirror = false


    @event = false


    setup


  end


  #--------------------------------------------------------------------------


  # ● カメラX座標


  #--------------------------------------------------------------------------


  def x


    return @x / 100


  end


  #--------------------------------------------------------------------------


  # ● カメラY座標


  #--------------------------------------------------------------------------


  def y


    return @y / 100


  end


  #--------------------------------------------------------------------------


  # ● ズーム率 


  #--------------------------------------------------------------------------


  def zoom


    return @zoom * 0.001


  end


  #--------------------------------------------------------------------------


  # ● ズーム率による座標変換


  #--------------------------------------------------------------------------


  def convert


    return @zoom


  end


  #--------------------------------------------------------------------------


  # ● カメラセットアップ


  #--------------------------------------------------------------------------


  def setup


    @x = 0


    @y = 0


    @sx = 0


    @sy = 0


    @zoom = 1000


    @time = 0


    @shake_time = 0


    program_setup


  end


  #--------------------------------------------------------------------------


  # ● カメラ初期化


  #--------------------------------------------------------------------------


  def reset


    @switches = []


    @max_data = []


    @color_set = []


    @wait = 0


    @win_wait = false


    @mirror = false


    program_setup(false)


  end  


  #--------------------------------------------------------------------------


  # ● バトルプログラムのセットアップ


  #--------------------------------------------------------------------------


  def program_setup(check = true)


    @played_program  = []


    @program_switch  = []


    @program_sound   = []


    @program_scroll  = []


    @program_se      = []


    @program_shake   = []


    @program_color   = []


    @program_picture = []


    @program_base = N03::BATTLE_PROGRAM.values.dup


    program_check if check


  end  


  #--------------------------------------------------------------------------


  # ● バトルプログラムのチェック


  #--------------------------------------------------------------------------


  def program_check


    for data in @program_base


      if program_start?(data) && !@played_program.include?(data)


        @played_program.push(data.dup)


        @program_scroll.push(data.dup)  if data[0] == "scroll"


        @program_picture.push(data.dup) if data[0] == "kpic"


        start_sound(data.dup)           if data[0] == "sound"


        start_program_switch(data.dup)  if data[0] == "switch"


        start_program_se(data.dup)      if data[0] == "keep_se"


        start_program_shake(data.dup)   if data[0] == "keep_sk"


        start_program_color(data.dup)   if data[0] == "keep_c"


      else


        @played_program.delete(data)  if !program_start?(data)


        @program_scroll.delete(data)  if data[0] == "scroll"


        @program_picture.delete(data) if data[0] == "kpic"


        @program_switch.delete(data)  if data[0] == "switch"


        @program_sound.delete(data)   if data[0] == "sound"


        @program_se.delete(data)      if data[0] == "keep_se"


        @program_shake.delete(data)   if data[0] == "keep_sk"


        @program_color.delete(data)   if data[0] == "keep_c"


      end


    end


  end


  #--------------------------------------------------------------------------


  # ● バトルプログラムの開始


  #--------------------------------------------------------------------------


  def program_start?(data)


    start = false


    start = true if $game_switches[data[1].abs] && data[1] > 0


    start = true if @switches[data[1].abs] && data[1] < 0


    return start


  end  


  #--------------------------------------------------------------------------


  # ● バトルプログラム スイッチ操作の開始


  #--------------------------------------------------------------------------


  def start_program_switch(data)


    data[4] = data[4] + rand(data[5] + 1)


    data[4] = 1 if data[4] <= 0


    @program_switch.push(data)


  end


  #--------------------------------------------------------------------------


  # ● スイッチ操作の更新


  #--------------------------------------------------------------------------


  def update_program_switch


    for data in @program_switch


      data[4] -= 1


      next @program_switch.delete(data) if data[1] > 0 && !$game_switches[data[1]]


      next @program_switch.delete(data) if data[1] < 0 && !@switches[data[1].abs]


      next if data[4] != 0


      for id in data[2]


        $game_switches[id] = true if id > 0


        @switches[id.abs] = true  if id < 0


      end


      for id in data[3]


        $game_switches[id] = false if id > 0


        @switches[id.abs] = false  if id < 0


      end


      @program_switch.delete(data)


      program_check


    end  


  end


  #--------------------------------------------------------------------------


  # ● バトルプログラム BGM/BGSの開始


  #--------------------------------------------------------------------------


  def start_sound(data)


    @program_sound.push(data)


    name = data[5]


    case data[2]


    when "se"


      Audio.se_play("Audio/SE/" + name, data[4], data[3])


    when "bgm"


      name = RPG::BGM.last.name if data[5] == ""


      Audio.bgm_play("Audio/BGM/" + name, data[4], data[3])


    when "bgs"


      name = RPG::BGS.last.name if data[5] == ""


      Audio.bgs_play("Audio/BGS/" + name, data[4], data[3])


    end


  end


  #--------------------------------------------------------------------------


  # ● バトルプログラム 周期SEの開始


  #--------------------------------------------------------------------------


  def start_program_se(data)


    data[3] = [data[2], data[3]]


    data[2] = data[3][0] + rand(data[3][1] + 1)


    @program_se.push(data)


    Audio.se_play("Audio/SE/" + data[7], data[5], data[4]) if data[6]


  end


  #--------------------------------------------------------------------------


  # ● 周期SEの更新


  #--------------------------------------------------------------------------


  def update_program_se


    for data in @program_se


      data[2] -= 1


      next @program_se.delete(data) if data[1] > 0 && !$game_switches[data[1]]


      next @program_se.delete(data) if data[1] < 0 && !@switches[data[1].abs]


      next if data[2] != 0


      Audio.se_play("Audio/SE/" + data[7], data[5], data[4])


      data[2] = data[3][0] + rand(data[3][1] + 1)


    end  


  end


  #--------------------------------------------------------------------------


  # ● バトルプログラム 周期シェイクの開始


  #--------------------------------------------------------------------------


  def start_program_shake(data)


    data[3] = [data[2], data[3]]


    data[2] = data[3][0] + rand(data[3][1] + 1)


    @program_shake.push(data)


    shake(data[4], data[5], data[6]) if data[7]


  end


  #--------------------------------------------------------------------------


  # ● 周期シェイクの更新


  #--------------------------------------------------------------------------


  def update_program_shake


    for data in @program_shake


      data[2] -= 1


      next @program_shake.delete(data) if data[1] > 0 && !$game_switches[data[1]]


      next @program_shake.delete(data) if data[1] < 0 && !@switches[data[1].abs]


      next if data[2] != 0


      shake(data[4], data[5], data[6])


      data[2] = data[3][0] + rand(data[3][1] + 1)


    end  


  end


  #--------------------------------------------------------------------------


  # ● バトルプログラム 周期色調変更の開始


  #--------------------------------------------------------------------------


  def start_program_color(data)


    data[3] = [data[2], data[3]]


    data[2] = data[3][0] + rand(data[3][1] + 1)


    data[7] = true if data[4] == 0 or data[4] == 4


    case data[4]


    when 1   ;data[4] = $game_troop.members


    when 2   ;data[4] = $game_party.battle_members


    when 3,4 ;data[4] = $game_troop.members + $game_party.battle_members


    else ;data[4] = []


    end


    @program_color.push(data)


    return if !data[6]


    for target in data[4] do target.sv.color_set = data[5] end if data[4] != []


    @color_set[1] = data[5] if data[7]


    @color_set[2] = data[5] if data[7]


  end


  #--------------------------------------------------------------------------


  # ● 周期色調変更の更新


  #--------------------------------------------------------------------------


  def update_program_color


    for data in @program_color


      data[2] -= 1


      next @program_color.delete(data) if data[1] > 0 && !$game_switches[data[1]]


      next @program_color.delete(data) if data[1] < 0 && !@switches[data[1].abs]


      next if data[2] != 0


      for target in data[4] do target.sv.color_set = data[5] end if data[4] != []


      @color_set[1] = data[5] if data[7]


      @color_set[2] = data[5] if data[7]


      data[2] = data[3][0] + rand(data[3][1] + 1)


    end 


  end


  #--------------------------------------------------------------------------


  # ● トランジション実行


  #--------------------------------------------------------------------------


  def perform_transition(data)


    Graphics.transition(data[2], "Graphics/Pictures/" + data[3], data[1])


  end  


  #--------------------------------------------------------------------------


  # ● 背景からカメラの限界値を取得  data = [max_top, max_bottom, max_left, max_right]


  #--------------------------------------------------------------------------


  def setting(index, data)


    @max_data[index - 1] = data


    return if index != 2


    setup


    # カメラの中心座標


    @center_x     = (Graphics.width / 2 + N03::CAMERA_POSITION[0]) * 100


    @center_y     = (Graphics.height / 2 + N03::CAMERA_POSITION[1]) * 100


    # 上下左右の移動限界距離


    @max_top    = [@max_data[0][5], @max_data[1][5]].min * -1


    @max_bottom = [@max_data[0][1], @max_data[1][1]].min + @max_top


    @max_left   = [@max_data[0][4], @max_data[1][4]].min  * -1


    @max_right  = [@max_data[0][3], @max_data[1][3]].min + @max_left


    exist_data = @max_data[0] if !@max_data[1][6]


    exist_data = @max_data[1] if !@max_data[0][6]


    @max_top    = exist_data[5] * -1        if exist_data != nil


    @max_bottom = exist_data[1] + @max_top  if exist_data != nil


    @max_left   = exist_data[4] * -1        if exist_data != nil


    @max_right  = exist_data[3] + @max_left if exist_data != nil


    @max_top = @max_bottom = @max_left = @max_right = 0 if !@max_data[1][6] && !@max_data[0][6]


    @max_width    = @max_right - @max_left + Graphics.width


    @max_height   = @max_bottom - @max_top + Graphics.height


    # ズームアウト限界値


    max_zoom_x    = 100 * Graphics.width / @max_width


    max_zoom_y    = 100 * Graphics.height / @max_height


    @max_zoom_out = [max_zoom_x, max_zoom_y].max


  end


  #--------------------------------------------------------------------------


  # ● カメラ移動


  #--------------------------------------------------------------------------


  def move(target_x, target_y, zoom, time, screen = true)


    # 戦闘背景以上のサイズまでズームアウトしないよう調整


    @target_zoom = [zoom * 0.01, @max_zoom_out * 0.01].max


    target_x *= -1 if screen && @mirror


    # ズーム分の中心座標補正


    if screen && @target_zoom != 1


      target_x = target_x + @center_x


      target_y = target_y + @center_y


    end


    adjust_x = @center_x * (@target_zoom - 1) / (@target_zoom ** 2 - @target_zoom)


    adjust_y = @center_y * (@target_zoom - 1) / (@target_zoom ** 2 - @target_zoom)


    adjust_x = 0 if adjust_x.nan?


    adjust_y = 0 if adjust_y.nan?


    adjust_x = @center_x if !screen && adjust_x == 0


    adjust_y = @center_y if !screen && adjust_y == 0


    @target_x = target_x - adjust_x.to_i


    @target_y = target_y - adjust_y.to_i


    @target_zoom = (@target_zoom * 1000).to_i


    @zoom = @zoom.to_i


    limit_test


    # 時間0の場合は即実行


    return @time = time.abs if time != 0


    @time = 1


    update


  end


  #--------------------------------------------------------------------------


  # ● 限界座標の試算


  #--------------------------------------------------------------------------


  def limit_test


    new_width = @max_width * @target_zoom / 1000


    new_height = @max_height * @target_zoom / 1000


    new_max_right = @max_right - (@max_width - new_width)


    new_max_bottom = @max_bottom - (@max_height - new_height)


    # 画面の移動先が限界の場合、限界座標をセット


    if @target_x < @max_left * 100


      @target_x = @max_left * 100


    end 


    if @target_x > new_max_right * 100


      @target_x = new_max_right * 100


    end


    if @target_y < @max_top * 100


      @target_y = @max_top * 100


    end


    if @target_y > new_max_bottom * 100


      @target_y = new_max_bottom * 100


    end


  end


  #--------------------------------------------------------------------------


  # ● 画面のシェイク


  #--------------------------------------------------------------------------


  def shake(power, speed, time)


    @shake_x = power[0] * 100


    @shake_y = power[1] * 100


    @power_time_base = @power_time = speed


    @shake_time = time


    update_shake


  end


  #--------------------------------------------------------------------------


  # ● シェイクの更新


  #--------------------------------------------------------------------------


  def update_shake


    @sx = (@sx * (@power_time - 1) + @shake_x) / @power_time


    @sy = (@sy * (@power_time - 1) + @shake_y) / @power_time


    @power_time -= 1


    @shake_time -= 1


    return @sx = @sy = 0 if @shake_time == 0


    return if @power_time != 0


    @power_time = @power_time_base


    @shake_x = @shake_x * -4 / 5


    @shake_y = @shake_y * -4 / 5


  end


  #--------------------------------------------------------------------------


  # ● フレーム更新


  #--------------------------------------------------------------------------


  def update


    update_shake if @shake_time != 0


    update_program


    return if @time == 0


    @x = (@x * (@time - 1) + @target_x) / @time


    @y = (@y * (@time - 1) + @target_y) / @time


    @zoom = (@zoom * (@time - 1) + @target_zoom) / @time


    @time -= 1


  end


  #--------------------------------------------------------------------------


  # ● フレーム更新


  #--------------------------------------------------------------------------


  def update_program


    update_program_switch if @program_switch != []


    update_program_se     if @program_se != []


    update_program_shake  if @program_shake != []


    update_program_color  if @program_color != []


  end


end


 


#==============================================================================


# ■ Scene_Battle


#------------------------------------------------------------------------------


# 　バトル画面の処理を行うクラスです。


#==============================================================================


class Scene_Battle < Scene_Base


  #--------------------------------------------------------------------------


  # ● フレーム更新（基本）


  #--------------------------------------------------------------------------


  alias update_basic_scene_battle_n03 update_basic


  def update_basic


    update_basic_scene_battle_n03


    $sv_camera.update


    $sv_camera.wait = N03::TURN_END_WAIT + 1 if $sv_camera.win_wait


    camera_wait


  end


  #--------------------------------------------------------------------------


  # ● カメラウェイト


  #--------------------------------------------------------------------------


  def camera_wait


    process_event if $sv_camera.event


    $sv_camera.event = false if $sv_camera.event


    while $sv_camera.wait != 0


      Graphics.update


      Input.update


      update_all_windows


      $game_timer.update


      $game_troop.update


      $sv_camera.update


      @spriteset.update


      update_info_viewport


      update_message_open


      $sv_camera.wait -= 1 if $sv_camera.wait > 0


      $sv_camera.wait = 1 if $sv_camera.wait == 0 && @spriteset.effect?


      BattleManager.victory if $sv_camera.win_wait && $sv_camera.wait == 0


    end


  end


  #--------------------------------------------------------------------------


  # ● カメラウェイトのセット


  #--------------------------------------------------------------------------


  def set_camera_wait(time)


    $sv_camera.wait = time


    camera_wait


  end  


  #--------------------------------------------------------------------------


  # ● エフェクト実行が終わるまでウェイト ★再定義


  #--------------------------------------------------------------------------


  def wait_for_effect


  end


  #--------------------------------------------------------------------------


  # ● ターン開始


  #--------------------------------------------------------------------------


  alias turn_start_scene_battle_n03 turn_start


  def turn_start


    turn_start_scene_battle_n03


    N03.camera(nil, N03::BATTLE_CAMERA["ターン開始後"].dup)


  end


  #--------------------------------------------------------------------------


  # ● ターン終了


  #--------------------------------------------------------------------------


  alias turn_end_scene_battle_n03 turn_end


  def turn_end


    turn_end_scene_battle_n03


    for member in $game_troop.members + $game_party.members


      N03.set_damage(member, member.sv.result_damage[0],member.sv.result_damage[1])


      member.sv.result_damage = [0,0]


      @spriteset.set_damage_pop(member) if member.result.hp_damage != 0 or member.result.mp_damage != 0


    end


    set_camera_wait(N03::TURN_END_WAIT)


    N03.camera(nil, N03::BATTLE_CAMERA["ターン開始前"].dup) if $game_party.inputable?


    @log_window.clear


  end


  #--------------------------------------------------------------------------


  # ● スキル／アイテムの使用 ★再定義


  #--------------------------------------------------------------------------


  def use_item


    item = @subject.current_action.item


    display_item(item)


    @subject.use_item(item)


    refresh_status


    @targets = @subject.current_action.make_targets.compact


    @targets = [@subject] if @targets.size == 0


    set_substitute(item)


    for time in item.repeats.times do play_sideview(@targets, item) end


    end_reaction(item)


    display_end_item


  end


  #--------------------------------------------------------------------------


  # ● スキル／アイテム名の表示


  #--------------------------------------------------------------------------


  def display_item(item)


    return @log_window.display_use_item(@subject, item) if N03::BATTLE_LOG


    @log_window.off


    @skill_name_window = Window_Skill_name.new(item.name) unless N03::NO_DISPLAY_SKILL_ID.include?(item.id) && item.is_a?(RPG::Skill)


  end  


  #--------------------------------------------------------------------------


  # ● スキル／アイテム名の表示終了


  #--------------------------------------------------------------------------


  def display_end_item


    @skill_name_window.dispose if @skill_name_window != nil


    @skill_name_window = nil


    set_camera_wait(N03::ACTION_END_WAIT) if @subject.sv.derivation_skill_id == 0


    @log_window.clear if N03::BATTLE_LOG


  end  


  #--------------------------------------------------------------------------


  # ● 反撃／魔法反射／身代わり処理


  #--------------------------------------------------------------------------


  def end_reaction(item)


    end_substitute if @substitute != nil


    set_reflection(item) if @reflection_data != nil


    set_counter_attack if @counter_attacker != nil


  end  


  #--------------------------------------------------------------------------


  # ● 反撃の発動 ★再定義


  #--------------------------------------------------------------------------


  def invoke_counter_attack(target, item)


    return if @subject.sv.counter_id != 0


    @counter_attacker = [] if @counter_attacker == nil


    return apply_item_effects(apply_substitute(target, item), item) if !target.movable?


    @log_window.add_text(sprintf(Vocab::CounterAttack, target.name)) if N03::BATTLE_LOG


    target.sv.counter_id = target.sv.counter_skill_id


    @counter_attacker.push(target)


  end


  #--------------------------------------------------------------------------


  # ● 魔法反射の発動 ★再定義


  #--------------------------------------------------------------------------


  def invoke_magic_reflection(target, item)


    return if @subject.sv.reflection_id != 0


    @log_window.add_text(sprintf(Vocab::MagicReflection, target.name)) if N03::BATTLE_LOG


    target.sv.reflection_id = target.sv.reflection_anime_id


  end


  #--------------------------------------------------------------------------


  # ● 身代わりの適用 ★再定義


  #--------------------------------------------------------------------------


  def apply_substitute(target, item)


    return target if @substitute == nil


    return target if !check_substitute(target, item)


    return @substitute


  end


  #--------------------------------------------------------------------------


  # ● 身代わりセット


  #--------------------------------------------------------------------------


  def set_substitute(item)


    @substitute = N03.get_enemy_unit(@subject).substitute_battler


    return if @substitute == nil


    s_targets = []


    for i in 0...@targets.size


      next if @targets[i] == @substitute


      next if !check_substitute(@targets[i], item)


      @log_window.add_text(sprintf(Vocab::Substitute, @substitute.name, @targets[i].name))


      @targets[i].sv.start_action(@targets[i].sv.substitute_receiver_start_action)


      s_targets.push(@targets[i])


      @targets[i] = @substitute


    end


    return @substitute = nil if s_targets == []


    @substitute.sv.set_target(s_targets)


    @substitute.sv.start_action(@substitute.sv.substitute_start_action)


  end  


  #--------------------------------------------------------------------------


  # ● 身代わり終了


  #--------------------------------------------------------------------------


  def end_substitute


    for member in @substitute.sv.target_battler


      member.sv.start_action(member.sv.substitute_receiver_end_action)


    end  


    @substitute.sv.start_action(@substitute.sv.substitute_end_action)


    @substitute = nil


  end


  #--------------------------------------------------------------------------


  # ● 反撃


  #--------------------------------------------------------------------------


  def set_counter_attack


    pre_subject = @subject


    for attacker in @counter_attacker


      @subject = attacker


      item = $data_skills[attacker.sv.counter_skill_id]


      play_sideview([pre_subject], item) 


    end


    # 同一カウンター者を考慮してカウンターIDの初期化はアクション後に実行


    for attacker in @counter_attacker do attacker.sv.counter_id = 0 end


    @subject = pre_subject


    @counter_attacker = nil


  end


  #--------------------------------------------------------------------------


  # ● 魔法反射


  #--------------------------------------------------------------------------


  def set_reflection(item)


    @log_window.back_to(1)


    for data in @reflection_data


      @subject.sv.damage_action(@subject, item)


      N03.set_damage_anime_data([@subject], @subject, data)


      apply_item_effects(@subject, item)


      @spriteset.set_damage_pop(@subject)


    end


    set_camera_wait(N03.get_anime_time(@reflection_data[0][0]))


    @reflection_data = nil


  end


  #--------------------------------------------------------------------------


  # ● サイドビューアクション実行


  #--------------------------------------------------------------------------


  def play_sideview(targets, item)


    @subject.sv.set_target(targets)


    return if @subject.sv.attack_action(item) == nil


    return if !@subject.movable?


    return if item.scope != 9 && item.scope != 10 && !N03.targets_alive?(targets)


    @subject.sv.start_action(@subject.sv.attack_action(item))


    @subject.sv.unshift_action(@subject.sv.flash_action) if @subject.flash_flg


    @subject.sv.active = true


    @subject.sv.command_action = false


    loop do


      update_basic


      data = @subject.sv.play_data


      @targets = N03.s_targets(@subject) if data[0] == "second_targets_set"


      N03.targets_set(@subject)          if data[0] == "targets_set"


      @immortal = N03.immortaling        if data[0] == "no_collapse" && !N03.dead_attack?(@subject, item)


      @immortal = N03.unimmortaling      if data[0] == "collapse"


      next set_move_anime(item)          if @subject.sv.m_a_data != []


      set_damage(item)                   if @subject.sv.set_damage


      break N03.derived_skill(@subject)  if @subject.sv.derivation_skill_id != 0


      break                              if @subject.sv.action_end or @subject.hidden?


    end


    @immortal = N03.unimmortaling        if @immortal


  end


  #--------------------------------------------------------------------------


  # ● ダメージの実行


  #--------------------------------------------------------------------------


  def set_damage(item)


    targets = @targets


    targets = [@subject.sv.individual_targets[0]] if @subject.sv.individual_targets.size != 0


    for target in targets do damage_anime(targets.dup, target, item) end


    @subject.sv.set_damage = false


    @subject.sv.damage_anime_data = []


  end


  #--------------------------------------------------------------------------


  # ● ダメージ戦闘アニメ処理


  #--------------------------------------------------------------------------


  def damage_anime(targets, target, item)


    @log_window.back_to(1) if @log_window.line_number == 5


    return if item.scope != 9 && item.scope != 10 && target.dead?


    @miss = false


    invoke_item(target,item)


    if target.result.missed


      target.sv.miss_action(@subject, item)


      return @miss = true


    elsif target.result.evaded or target.sv.counter_id != 0


      target.sv.evasion_action(@subject, item)


      return @miss = true


    elsif target.sv.reflection_id != 0


      N03.set_damage_anime_data(targets, target, [target.sv.reflection_id, false, false, true])


      target.sv.reflection_id = 0


      @reflection_data = [] if @reflection_data == nil


      return @reflection_data.push([N03.get_attack_anime_id(-3, @subject), false, false, true])


    end


    target.sv.damage_action(@subject, item)


    N03.set_damage(@subject, -target.result.hp_drain, -target.result.mp_drain) if target != @subject


    @spriteset.set_damage_pop(target)


    @spriteset.set_damage_pop(@subject) if target != @subject && @subject.result.hp_damage != 0 or @subject.result.mp_damage != 0


    N03.set_damage_anime_data(targets, target, @subject.sv.damage_anime_data) if @subject.sv.damage_anime_data != []


  end


  #--------------------------------------------------------------------------


  # ● 飛ばしアニメ処理


  #--------------------------------------------------------------------------


  def set_move_anime(item)


    for data in @subject.sv.m_a_data


      @subject.sv.damage_anime_data = data[4]


      hit_targets = []


      for target in data[1]


        damage_anime(data[1], target, item) if data[0]


        hit_targets.push(target) if !@miss


      end


      @miss = false if !data[3]


      @spriteset.set_hit_animation(@subject, data[2], hit_targets, @miss)


    end


    @subject.sv.set_damage = false


    @subject.sv.m_a_data = []


  end


end


 


#==============================================================================


# ■ DataManager


#------------------------------------------------------------------------------


# 　データベースとゲームオブジェクトを管理するモジュールです。


#==============================================================================


module DataManager


  #--------------------------------------------------------------------------


  # ● 各種ゲームオブジェクトの作成 ★再定義


  #--------------------------------------------------------------------------


  def self.create_game_objects


    $game_temp          = Game_Temp.new


    $game_system        = Game_System.new


    $game_timer         = Game_Timer.new


    $game_message       = Game_Message.new


    $game_switches      = Game_Switches.new


    $game_variables     = Game_Variables.new


    $game_self_switches = Game_SelfSwitches.new


    $game_actors        = Game_Actors.new


    $game_party         = Game_Party.new


    $game_troop         = Game_Troop.new


    $game_map           = Game_Map.new


    $game_player        = Game_Player.new


    $sv_camera          = Battle_Camera.new


  end


end


 


#==============================================================================


# ■ BattleManager


#------------------------------------------------------------------------------


# 　戦闘の進行を管理するモジュールです。


#==============================================================================


module BattleManager


  #--------------------------------------------------------------------------


  # ● エンカウント時の処理 ★再定義


  #--------------------------------------------------------------------------


  def self.on_encounter


    @preemptive = (rand < rate_preemptive)


    @surprise = (rand < rate_surprise && !@preemptive)


    $sv_camera.mirror = @surprise if N03::BACK_ATTACK


  end


  #--------------------------------------------------------------------------


  # ● 勝利の処理 ★再定義


  #--------------------------------------------------------------------------


  def self.process_victory


    $sv_camera.win_wait = true


  end  


  #--------------------------------------------------------------------------


  # ● 勝利


  #--------------------------------------------------------------------------


  def self.victory


    $sv_camera.win_wait = false 


    N03.camera(nil, N03::BATTLE_CAMERA["戦闘終了時"].dup)


    for member in $game_party.members do member.sv.start_action(member.sv.win) if member.movable? end


    play_battle_end_me


    replay_bgm_and_bgs


    $game_message.add(sprintf(Vocab::Victory, $game_party.name))


    display_exp


    gain_gold


    gain_drop_items


    gain_exp


    SceneManager.return


    battle_end(0)


    return true


  end


  #--------------------------------------------------------------------------


  # ● 逃走の処理 ★再定義


  #--------------------------------------------------------------------------


  def self.process_escape


    $game_message.add(sprintf(Vocab::EscapeStart, $game_party.name))


    success = @preemptive ? true : (rand < @escape_ratio)


    Sound.play_escape


    if success


      process_abort


      for member in $game_party.members do member.sv.start_action(member.sv.escape) if member.movable? end


    else


      @escape_ratio += 0.1


      $game_message.add('\.' + Vocab::EscapeFailure)


      $game_party.clear_actions


      for member in $game_party.members do member.sv.start_action(member.sv.escape_ng) if member.movable? end


    end


    wait_for_message


    return success


  end


  #--------------------------------------------------------------------------


  # ● 次のコマンド入力へ ★再定義


  #--------------------------------------------------------------------------


  def self.next_command


    begin


      if !actor || !actor.next_command


        $game_party.battle_members[@actor_index].sv.command_action = true


        @actor_index += 1


        if @actor_index >= $game_party.members.size


          for member in $game_party.battle_members.reverse


            break member.sv.start_action(member.sv.command_a) if member.inputable?


          end


          return false 


        end


      end


    end until actor.inputable?


    actor.sv.start_action(actor.sv.command_b) if actor != nil && actor.inputable?


    if pre_actor


      pre_actor.sv.start_action(pre_actor.sv.command_a) if pre_actor != nil && pre_actor.inputable?


    end


    return true


  end


  #--------------------------------------------------------------------------


  # ● 前のコマンド入力へ ★再定義


  #--------------------------------------------------------------------------


  def self.prior_command


    begin


      if !actor || !actor.prior_command


        $game_party.battle_members[@actor_index].sv.command_action = false


        @actor_index -= 1


        if @actor_index < 0


          for member in $game_party.battle_members


            break member.sv.start_action(member.sv.command_a) if member.inputable?


          end


          return false 


        end


      end


    end until actor.inputable?


    actor.make_actions if actor.inputable?


    actor.sv.start_action(actor.sv.command_b) if actor.inputable?


    after_actor.sv.start_action(after_actor.sv.command_a) if after_actor != nil && after_actor.inputable?


    return true


  end


  #--------------------------------------------------------------------------


  # ● コマンド入力前のアクターを取得


  #--------------------------------------------------------------------------


  def self.pre_actor


    return if @actor_index == 0


    $game_party.members[@actor_index - 1]


  end


  #--------------------------------------------------------------------------


  # ● コマンド入力後のアクターを取得


  #--------------------------------------------------------------------------


  def self.after_actor


    $game_party.members[@actor_index + 1]


  end


  #--------------------------------------------------------------------------


  # ● 戦闘行動者を前に追加


  #--------------------------------------------------------------------------


  def self.unshift_action_battlers(battler)


    @action_battlers.unshift(battler)


  end


end  


 


#==============================================================================


# ■ Game_Battler


#------------------------------------------------------------------------------


# 　スプライトや行動に関するメソッドを追加したバトラーのクラスです。


#==============================================================================


class Game_Battler < Game_BattlerBase


  #--------------------------------------------------------------------------


  # ● 公開インスタンス変数


  #--------------------------------------------------------------------------


  attr_reader   :sv                     # サイドビューデータ


  attr_accessor :flash_flg              # 閃きフラグ


  #--------------------------------------------------------------------------


  # ● オブジェクト初期化


  #--------------------------------------------------------------------------


  alias initialize_game_battler_n03 initialize


  def initialize


    initialize_game_battler_n03


    @sv = SideView.new(self)


  end


  #--------------------------------------------------------------------------


  # ● 現在の戦闘行動を除去


  #--------------------------------------------------------------------------


  alias remove_current_action_game_battler_n03 remove_current_action


  def remove_current_action


    return @sv.derivation_skill_id = 0 if @sv.derivation_skill_id != 0


    remove_current_action_game_battler_n03


  end


  #--------------------------------------------------------------------------


  # ● ターン終了処理


  #--------------------------------------------------------------------------


  alias on_turn_end_game_battler_n03 on_turn_end


  def on_turn_end


    on_turn_end_game_battler_n03


    @sv.add_state = []


    @sv.result_damage = [@result.hp_damage, @result.mp_damage]


  end


  #--------------------------------------------------------------------------


  # ● パラメータ条件比較 data = [種別, 数値, 判別]


  #--------------------------------------------------------------------------


  def comparison_parameter(data)


    return true if data[0][0] == 0


    kind = data[0]


    num = data[1]


    select = data[2]


    case kind


    when  1 ; par = level


    when  2 ; par = mhp


    when  3 ; par = mmp


    when  4 ; par = hp


    when  5 ; par = mp


    when  6 ; par = tp


    when  7 ; par = atk


    when  8 ; par = self.def


    when  9 ; par = mat


    when 10 ; par = mdf


    when 11 ; par = agi


    when 12 ; par = luk


    end


    if num < 0


      case kind


      when  4 ; num = mhp * num / 100


      when  5 ; num = mmp * num / 100


      when  6 ; num = max_tp * num / 100


      end


      num = num.abs


    end  


    case select


    when  0 ; return par == num


    when  1 ; return par < num


    when  2 ; return par > num


    end


  end


  #--------------------------------------------------------------------------


  # ● 装備条件比較 data = [装備種別, タイプID]


  #--------------------------------------------------------------------------


  def comparison_equip(data)


    kind = data[0]


    items = weapons if kind == 0


    items = armors  if kind == 1


    for item in items


      for id in data[1]


        return true if id > 0 && item.is_a?(RPG::Weapon) && item == $data_weapons[id.abs]


        return true if id > 0 && item.is_a?(RPG::Armor) && item == $data_armors[id.abs]


        return true if id < 0 && item.is_a?(RPG::Weapon) && item.wtype_id == id.abs


        return true if id < 0 && item.is_a?(RPG::Armor) && item.stype_id == id.abs


      end


    end


    return false


  end


 


end  


#==============================================================================


# ■ Game_Actor


#------------------------------------------------------------------------------


# 　アクターを扱うクラスです。


#==============================================================================


class Game_Actor < Game_Battler


  #--------------------------------------------------------------------------


  # ● 公開インスタンス変数


  #--------------------------------------------------------------------------


  attr_reader :actor_id                    # ID


  #--------------------------------------------------------------------------


  # ● ID


  #--------------------------------------------------------------------------


  def id


    return @actor_id


  end


  #--------------------------------------------------------------------------


  # ● スプライトを使うか？ ★再定義


  #--------------------------------------------------------------------------


  def use_sprite?


    return true


  end


  #--------------------------------------------------------------------------


  # ● ダメージ効果の実行 ★再定義


  #--------------------------------------------------------------------------


  def perform_damage_effect


    return if !N03::ACTOR_DAMAGE


    $game_troop.screen.start_shake(5, 5, 10)


    @sprite_effect_type = :blink


    Sound.play_actor_damage


  end


 


end


 


#==============================================================================


# ■ Game_Enemy


#------------------------------------------------------------------------------


# 　敵キャラを扱うクラスです。


#==============================================================================


class Game_Enemy < Game_Battler


  #--------------------------------------------------------------------------


  # ● 公開インスタンス変数


  #--------------------------------------------------------------------------


  attr_reader :enemy_id                    # ID


  #--------------------------------------------------------------------------


  # ● ID


  #--------------------------------------------------------------------------


  def id


    return @enemy_id


  end


  #--------------------------------------------------------------------------


  # ● レベル


  #--------------------------------------------------------------------------


  def level


    return @sv.level


  end


  #--------------------------------------------------------------------------


  # ● ダメージ効果の実行 ★再定義


  #--------------------------------------------------------------------------


  def perform_damage_effect


    return if !N03::ENEMY_DAMAGE


    @sprite_effect_type = :blink


    Sound.play_enemy_damage


  end


  #--------------------------------------------------------------------------


  # ● 武器


  #--------------------------------------------------------------------------


  def weapons


    weapon1 = $data_weapons[@sv.enemy_weapon1_id]


    weapon2 = $data_weapons[@sv.enemy_weapon2_id]


    return [weapon1, weapon2]


  end


  #--------------------------------------------------------------------------


  # ● 防具


  #--------------------------------------------------------------------------


  def armors


    return [$data_armors[@sv.enemy_shield_id]]


  end


  #--------------------------------------------------------------------------


  # ● 二刀流の判定


  #--------------------------------------------------------------------------


  def dual_wield?


    return $data_weapons[@sv.enemy_weapon2_id] != nil


  end


  #--------------------------------------------------------------------------


  # ● バトラー画像変更


  #--------------------------------------------------------------------------


  def graphics_change(battler_name)


    @battler_name = battler_name


  end


  #--------------------------------------------------------------------------


  # ● 通常攻撃 アニメーション ID の取得


  #--------------------------------------------------------------------------


  def atk_animation_id1


    return weapons[0].animation_id if weapons[0]


    return weapons[1] ? 0 : 1


  end


  #--------------------------------------------------------------------------


  # ● 通常攻撃 アニメーション ID の取得（二刀流：武器２）


  #--------------------------------------------------------------------------


  def atk_animation_id2


    return weapons[1] ? weapons[1].animation_id : 0


  end


end


 


#==============================================================================


# ■ Sprite_Base


#------------------------------------------------------------------------------


# 　アニメーションの表示処理を追加したスプライトのクラスです。


#==============================================================================


class Sprite_Base < Sprite


  #--------------------------------------------------------------------------


  # ● アニメーションの座標更新 (ホーミングあり)


  #--------------------------------------------------------------------------


  def update_animation_position_horming


    return if @action_end_cancel


    ani_ox_set if @horming


    camera_zoom = $sv_camera.zoom


    camera_zoom = 1 if @move_anime


    kind = 1


    kind = -1 if @ani_mirror && !@anime_no_mirror


    cell_data = @animation.frames[@animation.frame_max - (@ani_duration + @ani_rate - 1) / @ani_rate].cell_data


    for i in 0..15


      @ani_sprites[i].x = (@ani_ox + cell_data[i, 1] * kind - $sv_camera.x) * camera_zoom if @ani_sprites[i] != nil && cell_data[i, 1] != nil


      @ani_sprites[i].y = (@ani_oy + cell_data[i, 2] - $sv_camera.y) * camera_zoom if @ani_sprites[i] != nil && cell_data[i, 2] != nil


    end


  end


  #--------------------------------------------------------------------------


  # ● アニメーション元の座標をセット


  #--------------------------------------------------------------------------


  def ani_ox_set


    if !SceneManager.scene_is?(Scene_Battle)


      @real_x = x


      @real_y = y


    end


    @ani_ox = @real_x - ox + width / 2


    @ani_oy = @real_y - oy + height / 2


    @ani_oy -= height / 2 if @animation.position == 0


    @ani_oy += height / 2 if @animation.position == 2


  end


  #--------------------------------------------------------------------------


  # ● アニメーションの更新


  #--------------------------------------------------------------------------


  alias update_animation_sprite_base_n03 update_animation


  def update_animation


    update_animation_position_horming if animation? && SceneManager.scene_is?(Scene_Battle) && @animation.position != 3


    update_animation_sprite_base_n03


  end


  #--------------------------------------------------------------------------


  # ● アニメーションの原点設定 ★再定義


  #--------------------------------------------------------------------------


  def set_animation_origin


    return ani_ox_set if @animation.position != 3


    if viewport == nil


      @ani_ox = Graphics.width / 2


      @ani_oy = Graphics.height / 2


    else


      @ani_ox = viewport.rect.width / 2


      @ani_oy = viewport.rect.height / 2


    end


  end


  #--------------------------------------------------------------------------


  # ● アニメーションスプライトの設定 ★再定義


  #--------------------------------------------------------------------------


  def animation_set_sprites(frame)


    camera_zoom = 1


    camera_zoom = $sv_camera.zoom if @anime_camera_zoom && @animation.position != 3 && SceneManager.scene_is?(Scene_Battle)


    camera_x = $sv_camera.x


    camera_y = $sv_camera.y


    camera_x = camera_y = 0 if @animation.position == 3 or !SceneManager.scene_is?(Scene_Battle)


    plus_z = 5


    plus_z = 1000 if @animation.position == 3


    plus_z = -17 if @plus_z != nil && @plus_z == false


    plus_z = -self.z + 10 if @plus_z != nil && @plus_z == false && @animation.position == 3


    cell_data = frame.cell_data


    @ani_sprites.each_with_index do |sprite, i|


      next unless sprite


      pattern = cell_data[i, 0]


      if !pattern || pattern < 0


        sprite.visible = false


        next


      end


      sprite.bitmap = pattern < 100 ? @ani_bitmap1 : @ani_bitmap2


      sprite.visible = true


      sprite.src_rect.set(pattern % 5 * 192,


        pattern % 100 / 5 * 192, 192, 192)


      if @ani_mirror && !@anime_no_mirror


        sprite.x = (@ani_ox - cell_data[i, 1] - camera_x) * camera_zoom


        sprite.y = (@ani_oy + cell_data[i, 2] - camera_y) * camera_zoom


        sprite.angle = (360 - cell_data[i, 4])


        sprite.mirror = (cell_data[i, 5] == 0)


      else


        sprite.x = (@ani_ox + cell_data[i, 1] - camera_x) * camera_zoom


        sprite.y = (@ani_oy + cell_data[i, 2] - camera_y) * camera_zoom


        sprite.angle = cell_data[i, 4]


        sprite.mirror = (cell_data[i, 5] == 1)


      end


      sprite.z = self.z + plus_z + i


      sprite.ox = 96


      sprite.oy = 96


      sprite.zoom_x = cell_data[i, 3] * camera_zoom / 100.0


      sprite.zoom_y = cell_data[i, 3] * camera_zoom/ 100.0


      sprite.opacity = cell_data[i, 6] * self.opacity / 255.0


      sprite.blend_type = cell_data[i, 7]


    end


  end


  #--------------------------------------------------------------------------


  # ● 子スプライトフラグ


  #--------------------------------------------------------------------------


  def set(battler, horming, camera_zoom, no_mirror)


    @battler = battler


    @next = true


    self.bitmap = Bitmap.new(@battler.sv.cw, @battler.sv.ch)


    self.ox = bitmap.width / 2


    self.oy = bitmap.height


    @horming = horming


    @anime_camera_zoom = camera_zoom


    @anime_no_mirror = no_mirror


    @battler.sv.reset_anime_data


  end  


  #--------------------------------------------------------------------------


  # ● 子スプライト座標セット


  #--------------------------------------------------------------------------


  def set_position(z, zoom_x, zoom_y, real_x, real_y)


    self.z = z


    self.zoom_x = zoom_x


    self.zoom_y = zoom_y


    @real_x = real_x


    @real_y = real_y


  end


  #--------------------------------------------------------------------------


  # ● 他スプライトへのタイミング処理


  #--------------------------------------------------------------------------


  def other_process_timing(timing)


    se_flag = true


    se_flag = @se_flag if @se_flag != nil


    @battler.sv.timing.push([se_flag, timing.dup])


  end


  #--------------------------------------------------------------------------


  # ● 他バトラーへのタイミング処理


  #--------------------------------------------------------------------------


  def target_battler_process_timing(timing)


    for target in @timing_targets


      target.sv.timing.push([false, timing.dup])


    end  


  end


  #--------------------------------------------------------------------------


  # ● SE とフラッシュのタイミング処理


  #--------------------------------------------------------------------------


  alias animation_process_timing_sprite_base_n03 animation_process_timing


  def animation_process_timing(timing)


    target_battler_process_timing(timing) if @timing_targets && @timing_targets != []


    return other_process_timing(timing) if @next != nil


    animation_process_timing_sprite_base_n03(timing)


  end


  #--------------------------------------------------------------------------


  # ● アニメーションの解放


  #--------------------------------------------------------------------------


  alias dispose_animation_sprite_base_n03 dispose_animation


  def dispose_animation


    dispose_animation_sprite_base_n03


  end


end


 


 


#==============================================================================


# ■ Sprite_Battler


#------------------------------------------------------------------------------


# 　バトラー表示用のスプライトです。


#==============================================================================


class Sprite_Battler < Sprite_Base


  #--------------------------------------------------------------------------


  # ● 公開インスタンス変数　


  #--------------------------------------------------------------------------


  attr_accessor   :removing             # パーティ離脱中


  #--------------------------------------------------------------------------


  # ● オブジェクト初期化


  #--------------------------------------------------------------------------


  alias initialize_sprite_battler_n03 initialize


  def initialize(viewport, battler = nil)


    initialize_sprite_battler_n03(viewport, battler)


    @real_x = @real_y = 0


    update_bitmap if @battler != nil


  end


  #--------------------------------------------------------------------------


  # ● アニメーションの開始 ★再定義


  #--------------------------------------------------------------------------


  def start_animation(animation, mirror = false)


    return next_animation(animation, mirror) if animation?


    @animation = animation


    if @animation


      @horming = @battler.sv.anime_horming


      @anime_camera_zoom = @battler.sv.anime_camera_zoom


      @anime_no_mirror = @battler.sv.anime_no_mirror


      @timing_targets = @battler.sv.timing_targets


      @plus_z = @battler.sv.anime_plus_z


      @battler.sv.reset_anime_data


      @ani_mirror = mirror


      set_animation_rate


      @ani_duration = @animation.frame_max * @ani_rate + 1


      load_animation_bitmap


      make_animation_sprites


      set_animation_origin


    end


  end


  #--------------------------------------------------------------------------


  # ● 次のアニメを開始


  #--------------------------------------------------------------------------


  def next_animation(animation, mirror)


    @next_anime = [] if @next_anime == nil


    @next_anime.push(Sprite_Base.new(viewport))


    @next_anime[@next_anime.size - 1].set(battler, @battler.sv.anime_horming, @battler.sv.anime_camera_zoom, @battler.sv.anime_no_mirror)


    @next_anime[@next_anime.size - 1].set_position(self.z, self.zoom_x, self.zoom_y, @real_x, @real_y)


    @next_anime[@next_anime.size - 1].start_animation(animation, mirror)


  end


  #--------------------------------------------------------------------------


  # ● 影グラフィック作成


  #--------------------------------------------------------------------------


  def create_shadow


    reset_shadow


    return if @battler.sv.shadow == false


    @shadow = Sprite.new(viewport) if @shadow == nil


    @shadow.bitmap = Cache.character(@battler.sv.shadow)


    @shadow.ox = @shadow.bitmap.width / 2


    @shadow.oy = @shadow.bitmap.height / 2


  end


  #--------------------------------------------------------------------------


  # ● 影グラフィック初期化


  #--------------------------------------------------------------------------


  def reset_shadow


    return if @shadow == nil


    @shadow.dispose


    @shadow = nil


  end  


  #--------------------------------------------------------------------------


  # ● 転送元ビットマップの更新 ★再定義


  #--------------------------------------------------------------------------


  def update_bitmap


    update_bitmap_enemy if !@battler.actor?


    update_bitmap_actor if @battler.actor?


    update_src_rect if @battler != nil


    update_color if @battler != nil


  end


  #--------------------------------------------------------------------------


  # ● 転送元ビットマップ:エネミー


  #--------------------------------------------------------------------------


  def update_bitmap_enemy


    if @battler.battler_name != @battler_name or @battler.battler_hue != @battler_hue


      @battler_name = @battler.battler_name


      @battler_hue = @battler.battler_hue


      @battler_graphic_file_index = @battler.sv.graphic_file_index


      @graphic_mirror_flag = @battler.sv.graphic_mirror_flag


      self.bitmap = Cache.battler(@battler_name + @battler_graphic_file_index, @battler_hue)


      @battler.sv.setup(self.bitmap.width, self.bitmap.height, @battler_id != @battler.id)


      create_shadow


      init_visibility


      @battler_id = @battler.id


    end


  end  


  #--------------------------------------------------------------------------


  # ● 転送元ビットマップ:アクター


  #--------------------------------------------------------------------------


  def update_bitmap_actor


    if @battler.character_name != @battler_name or @battler.character_index != @battler_index


      @battler_name = @battler.character_name


      @battler_index = @battler.character_index


      @battler_graphic_file_index = @battler.sv.graphic_file_index


      @graphic_mirror_flag = @battler.sv.graphic_mirror_flag


      self.bitmap = Cache.character(@battler_name + @battler_graphic_file_index)


      @battler.sv.setup(self.bitmap.width, self.bitmap.height, @battler_id != @battler.id)


      create_shadow


      init_visibility


      @battler_id = @battler.id


    end


  end


  #--------------------------------------------------------------------------


  # ● 可視状態の初期化 ★再定義


  #--------------------------------------------------------------------------


  def init_visibility


    @battler_visible = @battler.alive?


    @battler_visible = true if @battler.sv.state(1) != "敵コラプス"


    @battler_visible = false if @battler.hidden?


    @battler.sv.opacity = 0 unless @battler_visible


    self.opacity = 0 unless @battler_visible


    self.opacity = 255 if @battler_visible


    @battler.sv.weapon_visible = @battler_visible


  end


  #--------------------------------------------------------------------------


  # ● 転送元矩形の更新


  #--------------------------------------------------------------------------


  def update_src_rect


    return if @battler.sv.collapse


    if @battler_graphic_file_index != @battler.sv.graphic_file_index


      @battler_graphic_file_index = @battler.sv.graphic_file_index


      self.bitmap = Cache.character(@battler_name + @battler_graphic_file_index) if @battler.actor?


      self.bitmap = Cache.battler(@battler_name + @battler_graphic_file_index, @battler_hue) if !@battler.actor?


      @battler.sv.set_graphics(self.bitmap.width, self.bitmap.height)


    end


    anime_off if @battler.sv.anime_off


    self.src_rect.set(@battler.sv.sx, @battler.sv.sy, @battler.sv.cw, @battler.sv.ch)


    self.opacity = @battler.sv.opacity if @battler_visible


    set_process_timing(@battler.sv.timing) if @battler && @battler.sv.timing != []


  end


  #--------------------------------------------------------------------------


  # ● 位置の更新 ★再定義


  #--------------------------------------------------------------------------


  def update_position


    @real_x = @battler.sv.x / 100


    @real_y = (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.c - @battler.sv.oy_adjust)/ 100


    self.x = @real_x - $sv_camera.x


    self.y = @real_y - $sv_camera.y


    self.z = @battler.sv.z - @battler.sv.c / 100


    if @battler.sv.h <= 0


      self.x += $sv_camera.sx / 100


      self.y += $sv_camera.sy / 100


    end  


    self.x *= $sv_camera.zoom


    self.y *= $sv_camera.zoom


  end


  #--------------------------------------------------------------------------


  # ● 原点の更新 ★再定義


  #--------------------------------------------------------------------------


  def update_origin


    return if !bitmap or @battler.sv.collapse


    self.ox = @battler.sv.ox


    self.oy = @battler.sv.oy


    self.angle = @battler.sv.angle


    self.zoom_x = @battler.sv.zoom_x * $sv_camera.zoom


    self.zoom_y = @battler.sv.zoom_y * $sv_camera.zoom


    self.mirror = @battler.sv.mirror if !@graphic_mirror_flag


    self.mirror = !@battler.sv.mirror if @graphic_mirror_flag


  end


  #--------------------------------------------------------------------------


  # ● 影グラフィックの更新


  #--------------------------------------------------------------------------


  def update_shadow


    @shadow.visible = @battler.sv.shadow_visible


    @shadow.opacity = @battler.sv.opacity if @battler.sv.opacity_data[3]


    @shadow.opacity = self.opacity if !@battler.sv.opacity_data[3]


    @shadow.x = @real_x - $sv_camera.x


    @shadow.y = (@battler.sv.y - @battler.sv.c)/ 100 - $sv_camera.y


    @shadow.z = @battler.sv.z - 10


    @shadow.zoom_x = $sv_camera.zoom


    @shadow.zoom_y = $sv_camera.zoom


    @shadow.x += $sv_camera.sx / 100


    @shadow.y += $sv_camera.sy / 100


    @shadow.x *= $sv_camera.zoom


    @shadow.y *= $sv_camera.zoom


    @shadow.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil


  end


  #--------------------------------------------------------------------------


  # ● ふきだしの更新


  #--------------------------------------------------------------------------


  def update_balloon


    if @battler.sv.balloon_data == [] && @balloon


      @balloon_data = []


      @balloon.dispose


      return @balloon = nil


    elsif @battler.sv.balloon_data != [] && @battler.sv.balloon_data != @balloon_data


      @balloon_data = @battler.sv.balloon_data


      @balloon = Sprite.new(self.viewport)


      @balloon.bitmap = Cache.system("Balloon")


      @balloon.zoom_x = @balloon_data[3]


      @balloon.zoom_y = @balloon_data[3]


      @balloon.ox = 32 if @battler.sv.mirror


      @balloon.oy = 16


      @balloon_count = 0


    end


    return if !@balloon


    @balloon.opacity = self.opacity


    @balloon.x = self.x


    @balloon.y = self.y - @battler.sv.ch * $sv_camera.zoom


    @balloon.z = self.z + 20


    @balloon.src_rect.set(32 + @balloon_count / @balloon_data[2] * 32, @balloon_data[1] * 32, 32, 32) if @balloon_count % @balloon_data[2] == 0


    @balloon.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil


    @balloon_count += 1


    @balloon_count = 0 if @balloon_count == @balloon_data[2] * 7


  end


  #--------------------------------------------------------------------------


  # ● 色調変更の更新


  #--------------------------------------------------------------------------


  def update_color


    color_set if @battler.sv.color_set != []


    return if @color_data == nil


    @color_data[4] -= 1


    if @color_data[4] == 0 && @color_data[5] != 0


      @color_data[4] = @color_data[5]


      @color_data[5] = 0


      @color_data[6] = [0,0,0,0]


    elsif @color_data[4] == 0


      @remain_color_data = @color_data


      @battler.sv.color = @color_data.dup


      return @color_data = nil


    end  


    for i in 0..3


      @color_data[i] = (@color_data[i] * (@color_data[4] - 1) + @color_data[6][i]) / @color_data[4]


    end  


    @battler.sv.color = @color_data.dup


    self.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3])


  end


  #--------------------------------------------------------------------------


  # ● 残像の更新


  #--------------------------------------------------------------------------


  def update_mirage


    if @battler.sv.mirage == [] && @mirages


      @mirage_data = []


      for mirage in @mirages do mirage.dispose end


      return @mirages = nil


    elsif @battler.sv.mirage != [] && @battler.sv.mirage != @mirage_data


      @mirage_data = @battler.sv.mirage


      @mirages = []


      for i in 0...@mirage_data[1] do @mirages[i] = Sprite.new(self.viewport) end


      @mirage_count = 0


    end


    return if !@mirages


    @mirage_count += 1


    @mirage_count = 0 if @mirage_count == @mirage_data[2] * @mirages.size


    for i in 0...@mirages.size


      mirage_body(@mirages[i], @mirage_data[4]) if @mirage_count == 1 + i * @mirage_data[2]


    end


  end


  #--------------------------------------------------------------------------


  # ● 残像本体


  #--------------------------------------------------------------------------


  def mirage_body(body, opacity)


    body.bitmap = self.bitmap.dup


    body.x = self.x


    body.y = self.y


    body.ox = self.ox


    body.oy = self.oy


    body.z = self.z - 20


    body.mirror = self.mirror


    body.angle = self.angle


    body.opacity = opacity * self.opacity / 255


    body.zoom_x = self.zoom_x


    body.zoom_y = self.zoom_y   


    body.src_rect.set(@battler.sv.sx, @battler.sv.sy, @battler.sv.cw, @battler.sv.ch)


    body.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil


  end   


  #--------------------------------------------------------------------------


  # ● 次のアニメを更新


  #--------------------------------------------------------------------------


  def update_next_anime


    return if !@next_anime


    for anime in @next_anime


      anime.update


      anime.set_position(self.z, self.zoom_x, self.zoom_y, @real_x, @real_y) if @horming


      anime.dispose if !anime.animation?


      @next_anime.delete(anime) if !anime.animation?


    end  


  end


  #--------------------------------------------------------------------------


  # ● フレーム更新


  #--------------------------------------------------------------------------


  alias update_sprite_battler_n03 update


  def update


    @battler.sv.update if @battler


    update_sprite_battler_n03


    update_next_anime


    update_shadow  if @battler && @shadow


    update_mirage  if @battler


    update_balloon if @battler


    update_remove if @battler && @removing && @battler.sv.change_up


  end


  #--------------------------------------------------------------------------


  # ● 戦闘アニメ消去


  #--------------------------------------------------------------------------


  def anime_off


    @battler.sv.anime_off = false


    dispose_animation


    for anime in @next_anime do anime.dispose_animation end if @next_anime


  end


  #--------------------------------------------------------------------------


  # ● バトラー入れ替え


  #--------------------------------------------------------------------------


  def remove


    @battler.sv.start_action(@battler.sv.remove_action)


    $sv_camera.wait = 40


    @battler.sv.add_action("eval('set_change')")


    @removing = true


  end


  #--------------------------------------------------------------------------


  # ● バトラー入れ替えの更新


  #--------------------------------------------------------------------------


  def update_remove


    @battler.sv.change_up = false


    @removing = false


    @battler = nil


  end  


  #--------------------------------------------------------------------------


  # ● バトラー加入


  #--------------------------------------------------------------------------


  def join(join_battler)


    $sv_camera.wait = 30


    @battler = join_battler


    @battler_name = @battler.character_name


    @battler_index = @battler.character_index


    @battler_graphic_file_index = @battler.sv.graphic_file_index


    self.bitmap = Cache.character(@battler_name)


    @battler.sv.setup(self.bitmap.width, self.bitmap.height, true)


    create_shadow


    init_visibility


  end


  #--------------------------------------------------------------------------


  # ● 通常の設定に戻す ★再定義


  #--------------------------------------------------------------------------


  def revert_to_normal


    self.blend_type = 0


    self.opacity = 255


  end


  #--------------------------------------------------------------------------


  # ● 崩壊エフェクトの更新


  #--------------------------------------------------------------------------


  alias update_collapse_sprite_battler_n03 update_collapse


  def update_collapse


    return if @battler.sv.state(1) != "敵コラプス"


    update_collapse_sprite_battler_n03


    @battler.sv.weapon_visible = false


  end


  #--------------------------------------------------------------------------


  # ● ボス崩壊エフェクトの更新 ★再定義


  #--------------------------------------------------------------------------


  def update_boss_collapse


    @effect_duration = @battler.sv.ch if @effect_duration >= @battler.sv.ch


    alpha = @effect_duration * 120 / @battler.sv.ch


    self.ox = @battler.sv.cw / 2 + @effect_duration % 2 * 4 - 2


    self.blend_type = 1


    self.color.set(255, 255, 255, 255 - alpha)


    self.opacity = alpha


    self.src_rect.y -= 1


    Sound.play_boss_collapse2 if @effect_duration % 20 == 19


  end


  #--------------------------------------------------------------------------


  # ● 別スプライトからのタイミング処理


  #--------------------------------------------------------------------------


  def set_process_timing(timing_data)


    for data in timing_data


      set_timing(data[0],data[1])


    end


    @battler.sv.timing = []


  end


  #--------------------------------------------------------------------------


  # ● タイミング処理


  #--------------------------------------------------------------------------


  def set_timing(se_flag, data)


    @ani_rate = 4


    data.se.play if se_flag


    case data.flash_scope


    when 1 ;self.flash(data.flash_color, data.flash_duration * @ani_rate)


    when 2 ;viewport.flash(data.flash_color, data.flash_duration * @ani_rate) if viewport


    when 3 ;self.flash(nil, data.flash_duration * @ani_rate)


    end


  end


  #--------------------------------------------------------------------------


  # ● 色調変更


  #--------------------------------------------------------------------------


  def color_set


    set = @battler.sv.color_set


    @battler.sv.color_set= []


    set[4] = 1 if set[4] == 0


    @remain_color_data = [0,0,0,0] if @remain_color_data == nil


    @color_data = @remain_color_data


    @color_data[4] = set[4]


    @color_data[5] = set[5]


    @color_data[6] = set


  end


  #--------------------------------------------------------------------------


  # ● 解放


  #--------------------------------------------------------------------------


  alias dispose_sprite_battler_n03 dispose


  def dispose


    dispose_sprite_battler_n03


    @shadow.dispose if @shadow != nil


    @balloon.dispose if @balloon != nil


    for mirage in @mirages do mirage.dispose end if @mirages != nil


    for anime in @next_anime do anime.dispose end if @next_anime


  end


end


 


 


#==============================================================================


# ■ Spriteset_Battle


#------------------------------------------------------------------------------


# 　バトル画面のスプライトをまとめたクラスです。


#==============================================================================


class Spriteset_Battle


  #--------------------------------------------------------------------------


  # ● 戦闘背景（床）スプライトの作成 ★再定義


  #--------------------------------------------------------------------------


  def create_battleback1


    @back1_sprite = Sprite_Battle_Back.new(@viewport1, 1, battleback1_name)


    @back1_sprite.set_graphics(battleback1_bitmap) if battleback1_name != nil


    @back1_sprite.z = 0


  end


  #--------------------------------------------------------------------------


  # ● 戦闘背景（壁）スプライトの作成 ★再定義


  #--------------------------------------------------------------------------


  def create_battleback2


    @back2_sprite = Sprite_Battle_Back.new(@viewport1, 2, battleback2_name)


    @back2_sprite.set_graphics(battleback2_bitmap) if battleback2_name != nil


    @back2_sprite.z = 1


  end


  #--------------------------------------------------------------------------


  # ● アクタースプライトの作成 ★再定義


  #--------------------------------------------------------------------------


  def create_actors


    @actor_sprites = []


    for i in 0...$game_party.max_battle_members


      @actor_sprites[i] = Sprite_Battler.new(@viewport1, $game_party.members[i])


    end


    @effect_sprites = Spriteset_Sideview.new(@viewport1)


  end


  #--------------------------------------------------------------------------


  # ● アクタースプライトの更新 ★再定義


  #--------------------------------------------------------------------------


  def update_actors


    @actor_sprites.each_with_index do |sprite, i|


      sprite_join($game_party.members[i], sprite) if sprite.battler == nil && sprite.battler != $game_party.members[i]


      sprite.remove if sprite.battler != nil && !sprite.removing && sprite.battler != $game_party.members[i]


      sprite.update


    end


    @effect_sprites.update


    update_program


  end


  #--------------------------------------------------------------------------


  # ● メンバーを加える


  #--------------------------------------------------------------------------


  def sprite_join(member, sprite)


    for sp in @actor_sprites


      sp.update_remove if member == sp.battler && !sp.battler.sv.change_up


    end


    sprite.join(member)


  end 


  #--------------------------------------------------------------------------


  # ● バトルプログラムの更新


  #--------------------------------------------------------------------------


  def update_program


    return if $sv_camera.program_scroll == []


    for data in  $sv_camera.program_scroll


      @back1_sprite.start_back_data(data) if data[2] == 1


      @back2_sprite.start_back_data(data) if data[2] == 2


    end


    $sv_camera.program_scroll = []


  end


  #--------------------------------------------------------------------------


  # ● ヒット時の戦闘アニメ実行


  #--------------------------------------------------------------------------


  def set_hit_animation(battler, weapon_index, hit_targets, miss)


    @effect_sprites.set_hit_animation(battler, weapon_index, hit_targets, miss)


  end


  #--------------------------------------------------------------------------


  # ● ダメージPOP


  #--------------------------------------------------------------------------


  def set_damage_pop(target)


    @effect_sprites.set_damage_pop(target)


  end


  #--------------------------------------------------------------------------


  # ● 解放


  #--------------------------------------------------------------------------


  alias dispose_spriteset_battle_n03 dispose


  def dispose


    dispose_spriteset_battle_n03


    @effect_sprites.dispose


  end


 


 


 


end


 


 


#==============================================================================


# ■ Window_BattleLog


#------------------------------------------------------------------------------


# 　戦闘の進行を実況表示するウィンドウです。


#==============================================================================


class Window_BattleLog < Window_Selectable


  #--------------------------------------------------------------------------


  # ● ウェイト ★再定義


  #--------------------------------------------------------------------------


  def wait


  end


  #--------------------------------------------------------------------------


  # ● ウェイトとクリア ★再定義


  #--------------------------------------------------------------------------


  def wait_and_clear


    $sv_camera.wait = 10


  end


  #--------------------------------------------------------------------------


  # ● 行動結果の表示 ★再定義


  #--------------------------------------------------------------------------


  def display_action_results(target, item)


    if target.result.used


      last_line_number = line_number


      display_critical(target, item)


      display_damage(target, item)


      display_affected_status(target, item)


      display_failure(target, item)


    end


    off if !N03::BATTLE_LOG


  end


  #--------------------------------------------------------------------------


  # ● ウインドウ非表示


  #--------------------------------------------------------------------------


  def off


    @back_sprite.visible = self.visible = false


  end


end


#==============================================================================


# ■ Game_Interpreter


#------------------------------------------------------------------------------


# 　イベントコマンドを実行するインタプリタです。


#==============================================================================


class Game_Interpreter


  #--------------------------------------------------------------------------


  # ● スイッチの操作


  #--------------------------------------------------------------------------


  alias command_121_game_interpreter_n03 command_121


  def command_121


    command_121_game_interpreter_n03


    $sv_camera.program_check


  end


end

SV里敌人死亡的动作设置问题
1.默认的敌人死亡动作是"崩溃"，是透明显示图片且不显示影子的 ；可能你又定义了关于“崩溃”的相关设定，导致有冲突，造成显示问题。
2.你可能把敌人死亡的动作也改为了角色的死亡动作，而角色默认死亡动作"倒下"只是切换了一帧图像，而这个动作是显示影子的。

YEP的 SV战斗可以关闭敌人影子

1.不知道"背景变暗队友透明","背暗队透除"这两个怎么定义的？ 我觉得是控制色调，这个不应该影响显示问题。
2.在技能后加个"15"的等待，防止一些小问题出现，看看情况。
3.排除法：把技能里的"透明化WT","透明化解除WT"（你这个写法透明化的对象貌似是敌人...）去掉，看看影子显示正常吗。