关于SV系统伤害数字坐标

贞九灵

现在敌人和自己的伤害数字都在脚下，请问在哪能调整伤害数字的坐标啊？

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 / 3) - i * 2 - @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 / 3) - i * 2 - @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

RUBY 代码复制

#==============================================================================
# ■ SideView 战斗者设定 Ver100
#------------------------------------------------------------------------------
#   将动作设定中制成的动作与战斗者绑定。
#   进行战斗者相关的设定
#==============================================================================
class SideView
  #--------------------------------------------------------------------------
  # ● 战斗者动画的横/纵元件数 = [横, 纵]。无动画为 [1, 1]
  #--------------------------------------------------------------------------
  def max_pattern
    # 根据战斗者 id 分歧
    case id
    when  1 # 1 号角色
      return [ 3, 4]
    when -1 # 1 号敌人 (敌人 ID 通过负数指定)
      return [ 1, 1]
    else # 上面的 ID 之外的统一设定
      return [ 3, 4] if id > 0 # 所有角色（ID 为正）
      return [ 1, 1] if id < 0 # 所有敌人（ID 为负）
    end
    # 之后的设定中，有根据 id 来分歧的话，请参考上面的描述。
  end
  #--------------------------------------------------------------------------
  # ● 影子的图片文件名  图像请放入 Characters 文件夹中。 false 为没有影子。
  #--------------------------------------------------------------------------
  def shadow
    return "shadow01" if id > 0 # 所有角色
    return false      if id < 0 # 所有敌人
  end
  #--------------------------------------------------------------------------
  # ● 战斗者图像翻转设定　初始状态时战斗者图像是否翻转。
  #--------------------------------------------------------------------------
  def graphic_mirror_flag
    return false if id > 0 # 所有角色
    return true  if id < 0 # 所有敌人
  end
  #--------------------------------------------------------------------------
  # ● 战斗者图像固定 战斗者动画设定的索引一定为 "" 的话设为 true
  #--------------------------------------------------------------------------
  def graphic_fix
    return false if id > 0 # 所有角色
    return true  if id < 0 # 所有敌人
  end
  #--------------------------------------------------------------------------
  # ● 通常待机
  #--------------------------------------------------------------------------
  def normal
    return "通常待机"   if id > 0 # 所有角色
    return "待机固定WT" if id < 0 # 所有敌人
    # 不一定要设置成全动作，只有动作也是可以的。
  end
  #--------------------------------------------------------------------------
  # ● 危机待机  HP 在 1/4 以下时的待机动作
  #--------------------------------------------------------------------------
  def pinch
    return "危机待机" if id > 0 # 所有角色
  end
  #--------------------------------------------------------------------------
  # ● 状态动作  多个状态重复时，显示优先度高的状态优先显示。
  #--------------------------------------------------------------------------
  def state(state_id)
    # 根据状态 ID 分歧
    case state_id
    when 1
      return "无法战斗"     if id > 0 # 所有角色
      return "敌死亡"   if id < 0 # 所有敌人
    when 2
      return "毒待机"
    when 6
      return "睡眠待机"
    when 3,4,5,7,8
      return "通用状态异常待机"
    when 9
      return "防御待机"
    end
  end
  #--------------------------------------------------------------------------
  # ● 输入命令后的动作
  #--------------------------------------------------------------------------
  def command
    # 根据选择的技能 ID 分歧
    case skill_id
    when 2
      return "命令后防御"
    end
    # 根据选择的技能类型指定
    case skill_type
    when 1 # 特技
      return "命令后特技"
    when 2 # 魔法
      return "命令后魔法"
    end
  end
  #--------------------------------------------------------------------------
  # ● 战斗开始动作
  #--------------------------------------------------------------------------
  def first_action
    return "战斗开始己方" if id > 0 # 所有角色
    return "待机固定WT"   if id < 0 # 所有敌人
  end
  #--------------------------------------------------------------------------
  # ● 胜利动作
  #--------------------------------------------------------------------------
  def win
    case id
    when  2,7,10 # 2号、7号、10号角色
      return "胜利姿态后空翻"
    else # 除此之外
      return "胜利姿态挥动"
    end
  end
  #--------------------------------------------------------------------------
  # ● 战斗退场动作  队伍成员变动时执行的退场动作
  #--------------------------------------------------------------------------
  def remove_action
    return "己方退场"
  end
  #--------------------------------------------------------------------------
  # ● 逃跑动作
  #--------------------------------------------------------------------------
  def escape
    return "逃走"   if id > 0 # 所有角色
    return "敌逃走" if id < 0 # 所有敌人
  end
  #--------------------------------------------------------------------------
  # ● 逃跑失败动作
  #--------------------------------------------------------------------------
  def escape_ng
    return "逃走失敗"
  end
  #--------------------------------------------------------------------------
  # ● 开始输入命令动作
  #--------------------------------------------------------------------------
  def command_b
    return "命令输入"
  end
  #--------------------------------------------------------------------------
  # ● 输入命令结束动作
  #--------------------------------------------------------------------------
  def command_a
    return "命令输入结束"
  end
  #--------------------------------------------------------------------------
  # ● 受伤动作
  #--------------------------------------------------------------------------
  def damage(attacker)
    # 致命一击时
    if critical?
      return "被伤害大"
    # 回复时
    elsif recovery?
      # 只有 return 表示没有动作
      return
    end
    # 根据技能 ID 分歧
    case damage_skill_id
    when 1 # 1 号技能
      return "被伤害"
    when 136 # 特定的技能不需要损伤动画时，在此以 return 表示
      return
    end
    # 根据道具 ID 指定（回复的动作已经指定完毕）
    case damage_item_id
    when 1 # 1 号道具
      return
    else
      # 除了上述道具之外
      if damage_item_id != 0
        return
      end
    end
    # 受伤为 0 时（强化、弱化魔法/防御/敌人逃跑等）
    if damage_zero?
      return
    end
    # 不符合上述设定时
    return "被伤害"
  end
  #--------------------------------------------------------------------------
  # ● 闪避动作  可以做出和受伤动作类似的分歧
  #--------------------------------------------------------------------------
  def evasion(attacker)
    return "盾格挡" if shield? # 装备了盾
    return "回避"
  end
  #--------------------------------------------------------------------------
  # ● 对方攻击未命中的动作
  # ● 相手の攻击ミス时の動作  可以做出和受伤动作类似的分歧
  #--------------------------------------------------------------------------
  def miss(attacker)
    return "盾格挡" if shield? # 装备了盾
    return "回避"
  end
  #--------------------------------------------------------------------------
  # ● 武器动作  普通攻击的动作由装备的武器指定。
  #             敌人可以通过下方的敌人武器设定来拥有武器。
  #--------------------------------------------------------------------------
  def weapon_action
    # 根据武器 ID 指定
    case weapon_id
    when 0 # 0 号武器（空手）
      return "通常攻击"
    when 1 # 1 号武器
      return "斩攻击"
    end
    # 根据武器类型指定
    case weapon_type
    when 1 # 武器类型为 1
      return "斩攻击"
    when 4,5,7,8,9 # 同时指定多个类型
      return "斩攻击"
    when 2
      return "拳攻击"
    when 3
      return "刺攻击"
    when 6
      return "弓攻击"
    end
  end
  #--------------------------------------------------------------------------
  # ● 敌人的右手武器  敌人也可以指定装备武器的 ID
  #--------------------------------------------------------------------------
  def enemy_weapon1_id
    case id
    when -1 # 1 号敌人（通过敌人 ID 的相反数进行分歧）
      return 10 # 指定武器 ID。0 为空手。
    else
      return 0
    end
  end
  #--------------------------------------------------------------------------
  # ● 敌人的右手武器   敌人也可以设定第二把武器 ID
  #--------------------------------------------------------------------------
  def enemy_weapon2_id
    return 0
  end
  #--------------------------------------------------------------------------
  # ● 敌人的盾  敌人也可以指定盾的 ID。优先级比左手武器高。
  #--------------------------------------------------------------------------
  def enemy_shield_id
    return 0
  end
  #--------------------------------------------------------------------------
  # ● 指定武器图像
  #--------------------------------------------------------------------------
  # 武器动作的类型设定中选择 [1:独立图像] [2:2003规格] 时
  # 对应的图片在此设定。
  # return "001-Weapon01" ←填入对应的武器图片名。
  #                         武器图片请放入 Characters 文件夹
  # 不想显示特定的武器时，请准备并设定为一张空白图片
  def weapon_graphic(weapon_id, weapon_type)
    # 根据武器 ID 指定
    case weapon_id
    when 1 # 1 号武器的图片文件名
      return ""
    end
    # 根据武器类型指定
    case weapon_type
    when 6 # 类型为 6 的武器的图片文件名
      return "bow01"
    end
  end
  #--------------------------------------------------------------------------
  # ● 指定盾的图片
  #--------------------------------------------------------------------------
  # 武器动作的类型设定中选择 [1:独立图像] [2:2003规格] ，
  # 并且在武器动作的反手设定中选择了 true 的时候，盾的图片在这里设定。
  #
  # return "001-Shield01" ←填入对应的盾的图片名。
  #                         盾的图片请放入 Characters 文件夹
  def shield_graphic(weapon_id, shield_type)
    # 根据防具 ID 指定
    case shield_id
    when 41 # 41号防具（小圆盾）的图片文件名
      return ""
    end
    # 根据防具类型指定
    case shield_type
    when 5 # 类型为 5 （小型盾）的盾的图片文件名
      return ""
    end
  end
 
  #--------------------------------------------------------------------------
  # ● 技能动作
  #--------------------------------------------------------------------------
  def skill_action
    # 根据技能 ID 指定
    case skill_id
    when 1 # 1 号技能为普通攻击，因此执行武器的动作
      return weapon_action
    when 2 # 2 号技能为防御
      return "防御"
    when 3,4,5 # 3/4/5 号技能为连续攻击
      return weapon_action
    when 6 # 6 号技能为敌人逃跑
      return escape
    when 7 # 7 号技能为观望
      return "观望"
    when 128
      return "水枪"
    when 129
      return "武器投掷"
    when 130
      return "5回攻击"
    when 131
      return "插入图片攻击"
    when 132
      return "影像攻击"
    when 133
      return "狼人变身"
    when 134
      return "特技派生"
    when 135
      return "变暗攻击"
    when 136
      return "空中攻击"
    end
    # 通过技能名指定（推荐，数据库中修改了技能ID也没有关系）
    case skill_name
    when "背景变更例子"
      return "背景变更攻击"
    when "图片攻击例子"
      return "图片攻击"
    end
    # 通过技能类型指定
    case skill_type
    when 1 # 特技
      return "通用特技"
    when 2 # 魔法
      return "通用魔法"
    end
    # 除此之外
    return "通用特技"
  end
  #--------------------------------------------------------------------------
  # ● 道具动作
  #--------------------------------------------------------------------------
  def item_action
    case item_id # 通过道具 ID 指定
    when 1
      return "使用物品"
    else
      return "使用物品"
    end
  end
  #--------------------------------------------------------------------------
  # ● 反击技能 ID  指定反击使用的技能 ID
  #--------------------------------------------------------------------------
  # ※数据库中设定的攻击次数无效
  def counter_skill_id
    return 1
  end
  #--------------------------------------------------------------------------
  # ● 魔法反射动画 ID  指定魔法反射时的动画 ID
  #--------------------------------------------------------------------------
  def reflection_anime_id
    return 118
  end
  #--------------------------------------------------------------------------
  # ● 替身开始动作
  #--------------------------------------------------------------------------
  def substitute_start_action
    return "替身开始"
  end
  #--------------------------------------------------------------------------
  # ● 替身结束动作
  #--------------------------------------------------------------------------
  def substitute_end_action
    return "替身结束"
  end
  #--------------------------------------------------------------------------
  # ● 被替身者的动作开始
  #--------------------------------------------------------------------------
  def substitute_receiver_start_action
    return "被替身开始"
  end
  #--------------------------------------------------------------------------
  # ● 被替身者的动作结束
  #--------------------------------------------------------------------------
  def substitute_receiver_end_action
    return "被替身结束"
  end
  #--------------------------------------------------------------------------
  # ● 敌人等级  用在条件分歧中，不会反映在属性里
  #--------------------------------------------------------------------------
  def level
    case id
    when -1 # 1 号敌人
      return 0
    end
    return 0
  end
 
end

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


# ■ SideView 战斗者设定 Ver100


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


#   将动作设定中制成的动作与战斗者绑定。


#   进行战斗者相关的设定


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


class SideView


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


  # ● 战斗者动画的横/纵元件数 = [横, 纵]。无动画为 [1, 1]


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


  def max_pattern


    # 根据战斗者 id 分歧


    case id


    when  1 # 1 号角色


      return [ 3, 4]


    when -1 # 1 号敌人 (敌人 ID 通过负数指定)


      return [ 1, 1]


    else # 上面的 ID 之外的统一设定


      return [ 3, 4] if id > 0 # 所有角色（ID 为正）


      return [ 1, 1] if id < 0 # 所有敌人（ID 为负）


    end


    # 之后的设定中，有根据 id 来分歧的话，请参考上面的描述。


  end


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


  # ● 影子的图片文件名  图像请放入 Characters 文件夹中。 false 为没有影子。


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


  def shadow


    return "shadow01" if id > 0 # 所有角色


    return false      if id < 0 # 所有敌人


  end


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


  # ● 战斗者图像翻转设定　初始状态时战斗者图像是否翻转。


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


  def graphic_mirror_flag


    return false if id > 0 # 所有角色


    return true  if id < 0 # 所有敌人


  end


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


  # ● 战斗者图像固定 战斗者动画设定的索引一定为 "" 的话设为 true


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


  def graphic_fix


    return false if id > 0 # 所有角色


    return true  if id < 0 # 所有敌人


  end


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


  # ● 通常待机


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


  def normal


    return "通常待机"   if id > 0 # 所有角色


    return "待机固定WT" if id < 0 # 所有敌人


    # 不一定要设置成全动作，只有动作也是可以的。


  end


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


  # ● 危机待机  HP 在 1/4 以下时的待机动作


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


  def pinch


    return "危机待机" if id > 0 # 所有角色


  end


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


  # ● 状态动作  多个状态重复时，显示优先度高的状态优先显示。


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


  def state(state_id)


    # 根据状态 ID 分歧


    case state_id


    when 1


      return "无法战斗"     if id > 0 # 所有角色


      return "敌死亡"   if id < 0 # 所有敌人


    when 2


      return "毒待机"


    when 6


      return "睡眠待机"


    when 3,4,5,7,8


      return "通用状态异常待机"


    when 9


      return "防御待机"


    end


  end


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


  # ● 输入命令后的动作


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


  def command


    # 根据选择的技能 ID 分歧


    case skill_id


    when 2


      return "命令后防御"


    end


    # 根据选择的技能类型指定


    case skill_type


    when 1 # 特技


      return "命令后特技"


    when 2 # 魔法


      return "命令后魔法"


    end


  end


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


  # ● 战斗开始动作


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


  def first_action


    return "战斗开始己方" if id > 0 # 所有角色


    return "待机固定WT"   if id < 0 # 所有敌人


  end


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


  # ● 胜利动作


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


  def win


    case id


    when  2,7,10 # 2号、7号、10号角色


      return "胜利姿态后空翻"


    else # 除此之外


      return "胜利姿态挥动"


    end


  end


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


  # ● 战斗退场动作  队伍成员变动时执行的退场动作


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


  def remove_action


    return "己方退场"


  end


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


  # ● 逃跑动作


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


  def escape


    return "逃走"   if id > 0 # 所有角色


    return "敌逃走" if id < 0 # 所有敌人


  end


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


  # ● 逃跑失败动作


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


  def escape_ng


    return "逃走失敗"


  end


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


  # ● 开始输入命令动作


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


  def command_b


    return "命令输入"


  end


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


  # ● 输入命令结束动作


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


  def command_a


    return "命令输入结束"


  end


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


  # ● 受伤动作


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


  def damage(attacker)


    # 致命一击时


    if critical?


      return "被伤害大"


    # 回复时


    elsif recovery?


      # 只有 return 表示没有动作


      return


    end


    # 根据技能 ID 分歧


    case damage_skill_id


    when 1 # 1 号技能


      return "被伤害"


    when 136 # 特定的技能不需要损伤动画时，在此以 return 表示


      return


    end


    # 根据道具 ID 指定（回复的动作已经指定完毕）


    case damage_item_id


    when 1 # 1 号道具


      return


    else


      # 除了上述道具之外


      if damage_item_id != 0


        return


      end


    end


    # 受伤为 0 时（强化、弱化魔法/防御/敌人逃跑等）


    if damage_zero?


      return


    end


    # 不符合上述设定时


    return "被伤害"


  end


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


  # ● 闪避动作  可以做出和受伤动作类似的分歧


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


  def evasion(attacker)


    return "盾格挡" if shield? # 装备了盾


    return "回避"


  end


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


  # ● 对方攻击未命中的动作


  # ● 相手の攻击ミス时の動作  可以做出和受伤动作类似的分歧


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


  def miss(attacker)


    return "盾格挡" if shield? # 装备了盾


    return "回避"


  end


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


  # ● 武器动作  普通攻击的动作由装备的武器指定。


  #             敌人可以通过下方的敌人武器设定来拥有武器。


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


  def weapon_action


    # 根据武器 ID 指定


    case weapon_id


    when 0 # 0 号武器（空手）


      return "通常攻击"


    when 1 # 1 号武器


      return "斩攻击"


    end


    # 根据武器类型指定


    case weapon_type


    when 1 # 武器类型为 1


      return "斩攻击"


    when 4,5,7,8,9 # 同时指定多个类型


      return "斩攻击"


    when 2


      return "拳攻击"


    when 3


      return "刺攻击"


    when 6


      return "弓攻击"


    end


  end


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


  # ● 敌人的右手武器  敌人也可以指定装备武器的 ID


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


  def enemy_weapon1_id


    case id


    when -1 # 1 号敌人（通过敌人 ID 的相反数进行分歧）


      return 10 # 指定武器 ID。0 为空手。


    else


      return 0


    end


  end


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


  # ● 敌人的右手武器   敌人也可以设定第二把武器 ID


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


  def enemy_weapon2_id


    return 0


  end


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


  # ● 敌人的盾  敌人也可以指定盾的 ID。优先级比左手武器高。


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


  def enemy_shield_id


    return 0


  end


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


  # ● 指定武器图像


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


  # 武器动作的类型设定中选择 [1:独立图像] [2:2003规格] 时


  # 对应的图片在此设定。


  # return "001-Weapon01" ←填入对应的武器图片名。


  #                         武器图片请放入 Characters 文件夹


  # 不想显示特定的武器时，请准备并设定为一张空白图片


  def weapon_graphic(weapon_id, weapon_type)


    # 根据武器 ID 指定


    case weapon_id


    when 1 # 1 号武器的图片文件名


      return ""


    end


    # 根据武器类型指定


    case weapon_type


    when 6 # 类型为 6 的武器的图片文件名


      return "bow01"


    end


  end


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


  # ● 指定盾的图片


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


  # 武器动作的类型设定中选择 [1:独立图像] [2:2003规格] ，


  # 并且在武器动作的反手设定中选择了 true 的时候，盾的图片在这里设定。


  #


  # return "001-Shield01" ←填入对应的盾的图片名。


  #                         盾的图片请放入 Characters 文件夹


  def shield_graphic(weapon_id, shield_type)


    # 根据防具 ID 指定


    case shield_id


    when 41 # 41号防具（小圆盾）的图片文件名


      return ""


    end


    # 根据防具类型指定


    case shield_type


    when 5 # 类型为 5 （小型盾）的盾的图片文件名


      return ""


    end


  end


 


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


  # ● 技能动作


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


  def skill_action


    # 根据技能 ID 指定


    case skill_id


    when 1 # 1 号技能为普通攻击，因此执行武器的动作


      return weapon_action


    when 2 # 2 号技能为防御


      return "防御"


    when 3,4,5 # 3/4/5 号技能为连续攻击


      return weapon_action


    when 6 # 6 号技能为敌人逃跑


      return escape


    when 7 # 7 号技能为观望


      return "观望"


    when 128


      return "水枪"


    when 129


      return "武器投掷"


    when 130


      return "5回攻击"


    when 131


      return "插入图片攻击"


    when 132


      return "影像攻击"


    when 133


      return "狼人变身"


    when 134


      return "特技派生"


    when 135


      return "变暗攻击"


    when 136


      return "空中攻击"


    end


    # 通过技能名指定（推荐，数据库中修改了技能ID也没有关系）


    case skill_name


    when "背景变更例子"


      return "背景变更攻击"


    when "图片攻击例子"


      return "图片攻击"


    end


    # 通过技能类型指定


    case skill_type


    when 1 # 特技


      return "通用特技"


    when 2 # 魔法


      return "通用魔法"


    end


    # 除此之外


    return "通用特技"


  end


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


  # ● 道具动作


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


  def item_action


    case item_id # 通过道具 ID 指定


    when 1


      return "使用物品"


    else


      return "使用物品"


    end


  end


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


  # ● 反击技能 ID  指定反击使用的技能 ID


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


  # ※数据库中设定的攻击次数无效


  def counter_skill_id


    return 1


  end


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


  # ● 魔法反射动画 ID  指定魔法反射时的动画 ID


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


  def reflection_anime_id


    return 118


  end


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


  # ● 替身开始动作


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


  def substitute_start_action


    return "替身开始"


  end


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


  # ● 替身结束动作


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


  def substitute_end_action


    return "替身结束"


  end


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


  # ● 被替身者的动作开始


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


  def substitute_receiver_start_action


    return "被替身开始"


  end


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


  # ● 被替身者的动作结束


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


  def substitute_receiver_end_action


    return "被替身结束"


  end


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


  # ● 敌人等级  用在条件分歧中，不会反映在属性里


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


  def level


    case id


    when -1 # 1 号敌人


      return 0


    end


    return 0


  end


 


end

RUBY 代码复制

#==============================================================================
# ■ SideView 动作設定 Ver100
#------------------------------------------------------------------------------
#  SideView 战斗总体设置、生成动作
#==============================================================================
module N03
 #--------------------------------------------------------------------------
 # ● 全体设定
 #--------------------------------------------------------------------------
  # 角色初始位置　        第一位       第二位       第三位       第四位
  #                    X轴 Y轴 H轴  X轴 Y轴 H轴  X轴 Y轴 H轴  X轴 Y轴 H轴
  ACTOR_POSITION   = [[415,160, 0],[435,185, 0],[455,210, 0],[475,235, 0]]
  # 行动结束时的等待时间（单位：帧）
  ACTION_END_WAIT = 8
  # 回合结束时的等待时间（单位：帧）
  TURN_END_WAIT = 12
  # 被敌人偷袭时，角色是否左右翻转。是：true；不是：false（下同）
  BACK_ATTACK = true
  # 队友受到伤害时，是否使用默认效果。
  ACTOR_DAMAGE = false
  # 敌方受到伤害时，是否使用默认效果。
  ENEMY_DAMAGE = false
  # 敌方战斗者的 X 坐标、计算旋转、战斗动画是否自动翻转。
  ENEMY_MIRROR = true
  # 用于禁止消失效果处理的，数据库中不死之身的状态 ID
  IMMORTAL_ID = 10
 
  # 是否显示战斗日志
  # 填入 false 时，会在画面上方显示技能名的窗口
  BATTLE_LOG = true
  # 技能名窗口打开时，将不需要表示的技能 ID 填入数组
  NO_DISPLAY_SKILL_ID = [1,2,3,4,5,6,7]
  # 是否弹出伤害数字
  DAMAGE_POP = true
  # 是否弹出附加状态
  STATE_POP = true
  # 伤害数字图片的文件名（参考System文件夹）
  DAMAGE_PLUS = "damage_num+"
  # 回复数字图片的文件名（参考System文件夹）
  DAMAGE_MINUS = "damage_num-"
  # MP 伤害数字图片的文件名（参考System文件夹）
  DAMAGE_MP = "damage_mp"
  # TP 伤害数字图片的文件名（参考System文件夹）
  DAMAGE_TP = "damage_tp"
  # 调整伤害数字之间的文字间距
  DAMAGE_ADJUST = -4
 
  # 调整战斗镜头的焦点 [X轴, Y轴]
  CAMERA_POSITION = [   0, -40]
 
 #--------------------------------------------------------------------------
 # ● 设置战斗背景 设定背景的坐标调整和放大率
 #--------------------------------------------------------------------------
  # 地板背景文件名...设定的地板背景图像文件名。
  #                 "全Battlebacks1"为未设定的Battlebacks1图像的默认值。
  # 墙壁背景文件名...设定的墙壁背景图像文件名。
  #                 "全Battlebacks2"为未设定的Battlebacks2图像的默认值。
  # 坐标调整...[X轴, Y轴]
  # 放大率...[横向, 纵向]
  # 允许震动...在震动动作中是否允许晃动。
  # 触发开关...开始战斗时自动打开的游戏开关 ID。设为负数则打开 SideView 专用开关。
  #           在想要集中管理背景和战斗程序的时候使用。
  #           不需要操作开关的话设为 0
 
   FLOOR1_DATA = {
 # 地板背景文件名             坐标调整      放大率    允许震动  触发开关
  "Sea_ex01"              => [ [   0, 120], [ 150, 150], false,   -1],
  "全Battlebacks1"        => [ [   0, 120], [ 150, 150],  true,    0],
 
  }
   FLOOR2_DATA = {
 # 墙壁背景文件名             坐标调整      放大率    允许震动  触发开关
  "Ship_ex"               => [ [   0, 120], [ 150, 150],  true,    0],
  "全Battlebacks2"        => [ [   0, 120], [ 150, 150],  true,    0],
 
 
}
 
#==============================================================================
# ■ 动作
#------------------------------------------------------------------------------
#   战斗者在战斗中的一次行动。组合起来成为全动作
#==============================================================================
 # 这里的动作名和全动作名请不要重复。
  ACTION = {
 
 #--------------------------------------------------------------------------
 # ● 战斗动画設定
 #--------------------------------------------------------------------------
  # 默认的行走套图是一个图片文件中设定了多名角色。
  # 使用行走套图的时候，追加图像请与角色的图像设定对应。
  # 角色与图像一一对应（文件名有 $ 前缀）时没有这个问题。
 
  # 索引...使用的战斗者图像文件后缀的索引名。
  #        SideView 的战斗者若为己方角色，会以角色行走图的文件名为准。
  #        带上索引后则会以 角色行走图文件名+索引名 的图像文件为准。
  #        例) Actor1 战斗者执行索引为"_1"的动画时，使用的文件名为 Actor1_1
  #        使用行走套图的时候，动画的索引名会为 ""
  #        角色的图像放进 Characters 文件夹，敌人的图像放进 Battlers 文件夹。
  #
  # 纵元...图像文件元件的纵向位置。从上往下分别为 0～3。数量上没有限制。
  #          元件数的设定在战斗者设定中。
  # 横元...动画开始播放的图像文件元件的横向位置。从左往右分别为 0～3。
  #          动画从这一元件开始从左向右播放。元件数量没有限制。
  # 模式... 0:元件固定 1:单向 2:反复 3:单向循环 4:反复循环
  # 速度...动画的更新速度。数字越小，更新越快。
  # Z轴...画面越前方数值越大。通常情况会显示在画面下方。
  # 等待...是否动画播放到最后再展开下一个行动。
  # 影子...是否显示影子的图像
  # 武器...如果要显示武器，天上武器的动作名，否则填入""。
  #        武器可以同时添加任意多个。添加的部分填在数组的后方。
 
  # 动作名（待机系）      判别     索引   纵元 横元 模式 速度  Z轴  等待 影子 武器
  "待机"            => ["motion",   "",    1,   0,   4,   12,   0, true, true, "" ],
  "待机固定WT"      => ["motion",   "",    1,   1,   0,   12,   0, true, true, "" ],
  "待机固定"        => ["motion",   "",    1,   1,   0,   12,   0,false, true, "" ],
  "死亡"            => ["motion", "_1",    0,   0,   0,   12,   0, true,false, "" ],
  "向右"            => ["motion",   "",    2,   0,   4,   12,   0, true, true, "" ],
 
  # 动作名（移动系）      判别      索引  纵元 横元  模式 速度  Z轴 等待  影子  武器
  "向左移动"         => ["motion",   "",    1,   0,   4,    6,  10, true, true, "" ],
  "向右移动"         => ["motion",   "",    2,   0,   4,    6,  10, true, true, "" ],
 
  # 动作名（静止系）      判别      索引  纵元 横元 模式 速度 Z轴  等待  影子   武器
  "武器拿出"        => ["motion",   "",    1,   0,   1,    2, 200,false, true, "拿出" ],
 
  # 动作名（攻击系）      判别     索引  纵元 横元 模式  速度 Z轴  等待  影子  武器
  "武器挥动R"       => ["motion",   "",    1,   0,   1,    2, 200,false, true, "纵挥动"],
  "武器挥动L"       => ["motion",   "",    1,   0,   1,    2, 200,false, true, "纵挥动L"],
  "武器挥动LR"      => ["motion",   "",    1,   0,   1,    2, 200,false, true, "纵挥动","纵挥动L"],
  "盾防御"          => ["motion",   "",    1,   0,   1,    2, 200,false, true, "盾"],
  "武器出拳"        => ["motion",   "",    1,   0,   1,    2, 200,false, true, "出拳" ],
  "武器刺"          => ["motion",   "",    1,   0,   1,    2, 200,false, true, "刺" ],
  "弓射击"          => ["motion",   "",    1,   0,   1,    2, 200,false, true, "弓"],
 
 #--------------------------------------------------------------------------
 # ● 战斗者的移动 敌人的 X 方向移动会自动反向计算
 #--------------------------------------------------------------------------
  # 目标...移动至目标坐标的参照对象。数值为正则参照现在位置，数值为负则参照初开始位置（[0=自身]无法设定为负，因此用 -7 表示）
  #       [0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标] [6=画面]
  # X轴...对象看到的X坐标
  # Y轴...对象看到的Y坐标
  # H轴...对象看到的H坐标（从地面算起的高度）。设置为 nil 则无视 H轴，只在 XY 方向移动。
  # 速度...每帧移动的像素数。负数表示指定时间，即移动完成耗费的总帧数。
  # 曲线...设为正数则向上，负数则向下弯曲。
  # 跳跃...跳跃的抛物线轨道。[从开始跳跃至顶点的轨道, 从顶点开始直到落地的轨道]
  # 动画...在移动中使用的战斗者动画的动作名。
 
  # 动作名（系统系）         判别  目标 X轴  Y轴  H轴 速度 曲线    跳跃     动画
  "战斗前己方配置"     => ["move",-7, 180,   0,   0,  0,   0, [  0,  0], "向左移动"],
  "退场"               => ["move",-7, 180,   0,   0,  7,   0, [  0,  0], "向右移动"],
  "逃走途中"           => ["move",-7,  80,   0,   0,  7,   0, [  0,  0], "向右移动"],
  "命令输入移动"       => ["move",-7, -20,   0, nil,-10,   0, [  0,  0], "向左移动"],
  "伤害的硬直"         => ["move", 0,  20,   0, nil,-10,   0, [  0,  0], ""],
  "伤害的硬直大"       => ["move", 0,  60,   0, nil,-10,   0, [  0,  0], ""],
 
  # 动作名（重置系）         判别  目标 X轴  Y轴  H轴 速度 曲线    跳跃     动画
  "坐标复位早"          => ["move",-7,   0,   0,   0,-10,   0, [  0,  0], "向右移动"],
  "坐标复位"            => ["move",-7,   0,   0,   0,-20,   0, [  0,  0], "向右移动"],
  "坐标复位曲线"        => ["move",-7,   0,   0,   0,-20,  -2, [  0,  0], "向右移动"],
  "坐标复位向左"        => ["move",-7,   0,   0,   0,-20,   0, [  0,  0], "向左移动"],
 
  # 动作名（自身系）         判别  目标 X轴  Y轴  H轴 速度 曲线    跳跃     动画
  "一步向前移动"        => ["move", 0, -20,   0,   0,-10,   0, [  0,  0], "向左移动"],
  "一步后移动"          => ["move", 0,  20,   0,   0,-10,   0, [  0,  0], "向左移动"],
  "一步前跳跃"          => ["move", 0, -30,   0,   0,-10,   0, [ 20,-20], "向左移动"],
  "一步后跳跃"          => ["move", 0,  30,   0,   0,-10,   0, [ 20,-20], "向左移动"],
  "胜利跳跃"            => ["move", 0,  10,   0,   0,-25,   0, [ 30,-30], "待机固定"],
  "胜利跳跃武器"        => ["move", 0,   0,   0,   0,-15,   0, [ 20,  0], "武器拿出"],
  "胜利跳跃着地"        => ["move",-7,   0,   0,   0,-10,   0, [  0,  0], "武器挥动R"],
  "纵晃动01"            => ["move", 0,   0,   0,  20, -2,   0, [  0,  0], ""],
  "纵晃动02"            => ["move", 0,   0,   0, -20, -2,   0, [  0,  0], ""],
 
  # 动作名（目标系）         判别  目标 X轴  Y轴  H轴 速度 曲线    跳跃     动画
  "敌前移动"            => ["move", 1,  30,   0,   0,-20,   0, [  0,  0], "向左移动"],
  "敌后移动"            => ["move", 1, -60,   0,   0,-20,   0, [  0,  0], "向左移动"],
  "敌中移动早"          => ["move", 1,   0,   0,   0,-10,   0, [  0,  0], "向左移动"],
  "杖打击前跳跃"        => ["move",-1,   0,   0, 100,-20,   0, [ 40,-20], "武器拿出"],
  "杖打击"              => ["move",-1,   0,   0,   0,-10,   0, [  0,  0], "武器挥动R"],
 
 #--------------------------------------------------------------------------
 # ● 武器动作 战斗者动画以及武器・投掷动画中使用的动作
 #--------------------------------------------------------------------------
  # 类型...[0...使用图标]
  #        [1...使用独立图像（图像名设置位于战斗者设定的武器项目。参照目标为 Characters 文件夹）]
  #        [2...动画元件（※2003规格。动画的元件数与战斗者相同。图像名设置位于战斗者设定的武器项目。参照目标为 Characters 文件夹）]
  # 移动...图片移动的距离。[X轴, Y轴]
  # 调整...图片微调的初开始坐标。[X轴, Y轴]
  # 开始度...动作前的角度。按照逆时针计算，0～360° 。 填入负数则为顺时针。
  # 终度...动作后的角度
  # 原点...图像的原点。[0...中心] [1...左上] [2...右上] [3...左下] [4...右下] [5...和战斗者相同（图像的下半部分）]
  # 翻转...图像是否翻转
  # 放大...[X轴放大率, Y轴放大率]。接受小数。
  # Z轴...图像是否显示在角色前方
  # 反手...盾图像，或者二刀流时显示左手武器。
  #        不使用图标时，盾的图像会按照战斗者设定的盾的项目来运行。
  #
  # 更新...设为-1则与战斗者动画同步更新。要特殊设置，设定为[更新时间间隔, 更新图案数目, 是否循环]
  #
  # 索引...本来会武器图像依据装备的武器（盾）上设定的图像文件名。
  #        在此加上索引后，则会依据 图像文件名+索引名 的图像。
  #        适用于同一武器有多种模式的图像的场合。
  #        例）"纵挥动"的索引为"" => 图像文件名为"IconSet"
  #        例）"纵挥动2"的索引为"_1" => 图像文件名为"IconSet_1"
  #        如果使用图标，则文件夹为 System 文件夹；如果使用独立画像或动画元件，则文件夹为 Characters 文件夹。
  #
  # 图像...想要无视武器和盾设定的图像文件和索引名，直接指定武器图像时，
  #        在这里填入图像文件名。图像放入 Characters 文件夹。
 
  # 动作名        判别 类型  移动     调整    开始度  终度 原点  翻转   拡大    Z轴   反手   更新   索引    图像
  "纵挥动"    => ["wp", 0,[  6, 0],[ -4,-10], -45,  45,  4, false, [1,1], false, false,   -1,   "",    ""],
  "盾"        => ["wp", 0,[  0, 0],[ 12,  0],   0,   0,  4, false, [1,1],  true,  true,   -1,   "",    ""],
  "纵挥动L"   => ["wp", 0,[  6, 0],[  0, -8],-135,  45,  4, false, [1,1],  true,  true,   -1,   "",    ""],
  "出拳"      => ["wp", 0,[-20, 0],[  5,  5], -45, -45,  4, false, [1,1], false, false,   -1,   "",    ""],
  "刺"        => ["wp", 0,[-25, 0],[ 25,-10],  45,  45,  4, false, [1,1], false, false,   -1,   "",    ""],
  "拿出"      => ["wp", 0,[  6,-4],[ -4,-10],  90, -45,  4, false, [1,1], false, false,   -1,   "",    ""],
 
  # 2003规格      判别 类型  移动     调整    开始度  终度 原点  翻转   拡大    Z轴   反手   更新   索引    图像
  "弓"        => ["wp", 2,[  0, 0],[  0,  0],   0,   0,  5, false, [1,1],  true, false,   -1,   "",    ""],
 
  # 投掷武器用    判别 类型  移动     调整    开始度  终度 原点  翻转   拡大    Z轴   反手      更新       索引    图像
  "箭"        => ["wp", 0,[  0, 0],[  0,  0],   0,  45,  0, false, [1,1],  true, false,[2,6,false],   "",    "arrow01"],
  "旋转"      => ["wp", 0,[  0, 0],[  0,  0],   0, 360,  0, false, [1,1],  true, false,[1,8, true],   "",    ""],
 
 #--------------------------------------------------------------------------
 # ● 投掷武器・道具 能使武器和战斗动画移动。用于飞行道具中。
 #--------------------------------------------------------------------------
  # ID...数据库中的动画ID。[要移动的动画 ID，打击时的动画 ID] 0 为不显示动画，-1 为显示武器动画。
  # 开始...动画开始移动的位置。设为负数，则即使有多个目标，也只显示一个动画。
  #     [0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标] [6=画面]
  # 末...动画结束移动的位置。设为负数，则即使有多个目标，也只显示一个动画。
  #     [0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标] [6=画面]
  # 开始调整...微调开始移动的坐标。[X轴, Y轴]。敌人的X轴会自动反向计算。
  # 末调整...微调结束移动的坐标。[X轴, Y轴]。敌人的X轴会自动反向计算。
  # 速度...每帧在X轴上移动的像素数。设为负数则按照时间设定，速度会根据距离而改变。
  # 类型...移动后的处理。[0=消失（未命中时自动变为穿透）] [1=穿透] [2=消失（未命中时也会消失）]
  # 轨道...移动的轨道。[从开始直至顶点的轨道, 从顶点开始直到落地的轨道]
  # Z轴...动画和武器是否显示在角色前方。
  # 等待...是否直到该动作结束后才转到下一个动作。[要移动的动画是否等待, 命中时的动画是否等待]
  # 伤害...是否在目标到达时计算伤害。
  # 追踪...是否对移动的目标追踪。
  # 镜头...动画是否会随着镜头缩放而放大缩小。
  # 循环...移动动画结束时，是否回到动画开始。
  # 禁止翻转...禁止在任何情况下翻转动画。
  # 武器...填入武器的动作名。不需要的话填入""
 
  # 动作名             判别     ID    开始 末  开始调整   末调整  速度 类型  轨道    Z轴       等待        伤害    追踪   镜头   循环 禁止翻转  武器
  "箭发射WT"       => ["m_a",[ 0,-1], 0, 1, [ 0, 0], [ 0, 0], 10,  2, [-3,-3], true, [ true, true],  true,  true,  true, false, false,  "箭"],
  "箭发射"         => ["m_a",[ 0,-1], 0, 1, [ 0, 0], [ 0, 0], 10,  2, [-3,-3], true, [false,false],  true,  true,  true, false, false,  "箭"],
  "水枪发射"       => ["m_a",[69,69], 0, 1, [ 0, 0], [ 0, 0], 10,  0, [ 0, 0], true, [ true, true],  true,  true,  true,  true, false,  ""],
  "武器投掷开始"   => ["m_a",[ 0,-1], 0, 1, [ 4,-6], [ 0, 0], 10,  2, [-3,-3], true, [ true,false],  true,  true,  true, false, false,  "旋转"],
  "武器投掷返回"   => ["m_a",[ 0, 0], 1, 0, [ 0, 0], [ 4,-6], 10,  0, [ 3, 3], true, [ true,false], false,  true,  true, false, false,  "旋转"],
 
 #--------------------------------------------------------------------------
 # ● 战斗动画 显示数据库中的战斗动画
 #--------------------------------------------------------------------------
  # ID...动画ID。-1 为武器设定的动画，-2 为二刀流另一只手的武器动画
  #              -3 为技能设定的动画
  # 对象...[0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标]
  # 追踪...动画是否会追踪对象坐标的移动。
  # 等待...是否等待到动画结束。
  # 伤害...是否应用伤害计算
  # 镜头...是否随着镜头缩放而放大缩小。
  # 禁止翻转...禁止在任何情况下翻转动画。
  # 翻转...翻转动画。
  # Z轴...动画是否显示在角色前方。
 
  # 动作名（伤害系）        判别     ID 对象  追踪   等待   伤害    镜头 禁止翻转  翻转    Z轴
  "对象动画武器"      => ["anime",  -1,  1, false, false,  true,  true, false,  false,  true],
  "对象动画武器WT"    => ["anime",  -1,  1, false,  true,  true,  true, false,  false,  true],
  "对象动画武器LWT"   => ["anime",  -2,  1, false,  true,  true,  true, false,  false,  true],
  "对象动画"          => ["anime",  -3,  1, false, false,  true,  true, false,  false,  true],
  "对象动画WT"        => ["anime",  -3,  1, false,  true,  true,  true, false,  false,  true],
 
 
  # 动作名（自身系）          判别     ID 对象  追踪   等待   伤害    镜头 禁止翻转  翻转    Z轴
  "魔法吟唱中"          => ["anime", 113,  0,  true,  true, false,  true, false,  false,  true],
  "特技待机中"          => ["anime", 114,  0,  true,  true, false,  true, false,  false,  true],
  "魔法发动动画"        => ["anime", 115,  0, false,  true, false,  true, false,  false, false],
  "特技发动动画"        => ["anime", 116,  0, false,  true, false,  true, false,  false, false],
 
 #--------------------------------------------------------------------------
 # ● 镜头动作 执行画面的缩放和滚动
 #--------------------------------------------------------------------------
  # 对象...移动和缩放的对象
  #       [0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标] [6=画面]
  # 调整坐标...微调镜头坐标的最终地点 [X轴（正值为向右）, Y轴（正值为向下）]
  # 时间...镜头动作所需的时间
  # 缩放...镜头的缩放率（%）。100表示无缩放。
  # 等待...是否等待镜头动作结束。
 
  # 动作名            判别     对象   调整坐标   缩放  时间  等待
  "镜头复位"     => ["camera",   6, [   0,   0], 100,  40, false],
  "放大"         => ["camera",   6, [   0, 100], 120,  40, false],
  "缩小"         => ["camera",   6, [   0,   0],  80,  40, false],
 
 #--------------------------------------------------------------------------
 # ● 画面的震动 震动画面。空中坐标（H坐标在0以上）的战斗者不会震动。
 #--------------------------------------------------------------------------
  # 方向...震动的方向 [横, 纵]。数值越大，振幅越大。
  # 速度...震动的速度。数值越小，震动越快。
  # 时间...震动的持续时间。振幅会随着时间逐渐减小。
  # 等待...是否等待震动结束。
 
  # 动作名          判别       方向  速度   时间   等待
  "震动小"     => ["shake", [  0, 4],  2,    16, false],
  "震动中"     => ["shake", [  0, 6],  3,    30, false],
  "震动大"     => ["shake", [  0,12],  3,    40, false],
 
 #--------------------------------------------------------------------------
 # ● 更改画面色调 更改背景和战斗者的色调
 #--------------------------------------------------------------------------
  # 对象...更改色调的对象
  #       [0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标]
  #       [6=背景] [7=自身+目标] [8=自身以外] [9=自身+目标以外] [10=全体]
  # 色调等级...[ R, G, B, alpha（颜色的强度）, 更改时间, ※返回]
  #             ※返回....更改结束之后返回原色调所需时间。不反回的话填入 0
  # 等待...是否等待至画面色调更改结束
 
  # 更改名                        判别    对象     R,   G,   B, alpha 时间 返回  等待
  "色调初始化"               => ["color",  10, [   0,   0,   0,   0,  30,   0], false],
  "危机色调"                 => ["color",   0, [ 255,  50,  50, 100,  40,  40], false],
  "毒色调"                   => ["color",   0, [ 170,  50, 255, 170,  30,  30], false],
  "通用状态异常色调"         => ["color",   0, [ 255, 255,  50, 170,  40,  40], false],
  "背景变暗"                 => ["color",   6, [   0,   0,   0, 255,  30,   0], false],
  "除自己以外全变暗"         => ["color",   9, [   0,   0,   0, 255,  30,   0], false],
 
 #--------------------------------------------------------------------------
 # ● 渐变 画面固定后执行的渐变
 #--------------------------------------------------------------------------
  # 执行前请先执行动作"画面固定"固定住画面。
 
  # 边界...边界的模糊程度。数值越大越模糊。
  # 时间...渐变花费的事件。渐变过程中游戏的画面会固定住。
  # 渐变文件名...渐变用图像。请将图像放入 Pictures 文件夹。
 
  # 动作名              判别   边界  时间  渐变文件名
  "圆圈"         => ["ts",  40,   60,  "circle"],
 
 #--------------------------------------------------------------------------
 # ● 残影 战斗者的移动留下残影
 #--------------------------------------------------------------------------
  # 数...残影的个数。0 为消除正在显示的残影。数目过多会增加负荷。
  # 间隔...残影显示的间隔。数值越小，间隔越窄。单位为 1 帧。
  # 处理...残影的善后处理。true 表示全动作完成时消失，false表示开始终显示。
  # 透明度...残影的透明度。
 
  # 动作名              判别     数 间隔   处理  透明度
  "残像ON"        => ["mirage",  4,   3,  true,  160],
  "残像OFF"       => ["mirage",  0,   0,  true,    0],
 
 #--------------------------------------------------------------------------
 # ● 旋转战斗者 旋转战斗者的图像
 #--------------------------------------------------------------------------
  # 旋转的战斗者在全动作结束之后，旋转效果会被重置。
  # 旋转中的画像传送原点为画像中心。和翻转不同，不会体现在武器动作中。
  #
  # 时间...旋转耗费的事件。0 表示立刻旋转完成。
  # 开始度...开始旋转时的角度。指定 0～360° 。正为逆时针，负为顺时针。
  # 终度...旋转结束时的角度。指定 0～360° 。和上一条一样，敌人会按照相反方向计算。
  # 种类...旋转结束后的处理。[0...旋转重置] [1...保持结束时的角度] [2...训话]
 
  # 动作名  　          判别    时间  开始度  终度  种类
  "右1旋转"        => ["angle",  12,    0, -360,   0],
  "左1旋转"        => ["angle",  12,    0,  360,   0],
 
 #--------------------------------------------------------------------------
 # ● 缩放战斗者 缩放战斗者的图像
 #--------------------------------------------------------------------------
  # 缩放的战斗者在全动作结束之后，缩放效果会被重置。
  # 和翻转不同，不会体现在武器动作中。
  #
  # 时间...缩放所花费的时间。
  # 开始大小...缩放开始时的大小。请输入小数。[X轴（横向）, Y轴（纵向）]
  # 结束大小...缩放结束时的大小。请输入小数。[X轴（横向）, Y轴（纵向）]
  # 类型...缩放结束后的处理。[0...缩放重置] [1...保持结束时的大小] [2...循环]
 
  # 动作名  　          判别    时间  开始大小      结束大小  种类
  "横缩"           => ["zoom",  12,  [1.0, 1.0],  [0.5, 1.0],  0],
  "纵缩"           => ["zoom",  12,  [1.0, 1.0],  [1.0, 0.5],  0],
 
 #--------------------------------------------------------------------------
 # ● 战斗者透明度操作 更改战斗者图像的透明度
 #--------------------------------------------------------------------------
  # 更改过透明度的战斗者在全动作结束之后，透明度操作会被重置。
  #
  # 时间...更改透明度所耗费的时间。
  # 开始...开始更改时的透明度。0 为完全消失的状态，255 为完全不透明的状态
  # 结束...结束更改时的透明度。
  # 影...影子是否同样更改透明度。
  # 武器...武器是否同样更改透明度。
  # 循环...透明度更改结束后，操作是否自动回滚。
  # 等待...是否等到操作结束后再执行下一个动作。
 
  # 动作名 　              判别      时间  开始  结束   影    武器   循环   等待
  "逃走透明"         => ["opacity",   30,  255,   0,  true,  true, false, false],
  "透明化"           => ["opacity",   60,  255,   0,  true,  true, false, false],
  "透明化WT"         => ["opacity",   60,  255,   0,  true,  true, false,  true],
  "透明化解除"       => ["opacity",   60,    0, 255,  true,  true, false, false],
  "透明化解除WT"     => ["opacity",   60,    0, 255,  true,  true, false,  true],
 
 #--------------------------------------------------------------------------
 # ● fuki 动画 显示事件中弹出的图标
 #--------------------------------------------------------------------------
  # 种类...用 0～9 指定fuki的种类（纵位置）
  # 速度...更新速度。元件会从第二格开始播放。
  # 大小...fuki的大小
 
  # fuki 动画名　　       判别      种类 速度  大小
  "状态异常/通用"   => ["balloon",   6,  10,  0.6],
  "状态异常/危机" => ["balloon",   5,  10,  0.6],
  "状态异常/睡眠"   => ["balloon",   9,  10,  0.6],
 
 #--------------------------------------------------------------------------
 # ● 显示图片 用于大招显示立绘等
 #--------------------------------------------------------------------------
  # ID...使用的图片 ID。用于管理图片的 ID。不限制显示图片的数量。
  #      在全动作结束后会自动消除（释放 Bitmap）。
  # 开始坐标...移动开始的位置。以图片左上方为原点。[X轴, Y轴]
  #            如果已经存在图片，设为 [] 会以该位置作为开始坐标。
  # 结束坐标...移动结束的位置。若与开始位置相同，则图片只会显示不会移动。
  #            使用平面的场合，把开始和结束设为 [] 则保持移动速度。
  # 时间...移动时间。设为 0 表示消除图片。
  # Z轴...图片的Z坐标。设为 100 以上则显示在窗口前方。
  # 透明度...设定透明度。[开始时的透明度，每帧透明度的增加值]
  # 使用平面...使用平面类（图片平铺）时的矩形。[X轴, Y轴]
  #            不使用平面则设为 []
  # BA翻转...被偷袭时是否图像翻转、X坐标反向移动。
  #          使用平面时，设为 true 也不会翻转，仅仅会反向移动 X 坐标。
  # 图片文件名...Pictures 文件夹内的文件名。
 
  # 动作名              判别   ID    开始坐标     结束坐标    时间 Z轴   透明度    使用平面  偷袭翻转 图片文件名
  "插入A1"          => ["pic",  0, [-300,   8], [ 100,   8],  30, 90, [  0, 10],        [],  true, "Actor4-1"],
  "插入A2"          => ["pic",  0, [-300,   8], [ 100,   8],  30, 90, [  0, 10],        [],  true, "Actor4-2"],
  "插入A3"          => ["pic",  0, [-300,   8], [ 100,   8],  30, 90, [  0, 10],        [],  true, "Actor5-2"],
  "插入A4"          => ["pic",  0, [-300,   8], [ 100,   8],  30, 90, [  0, 10],        [],  true, "Actor5-3"],
  "插入終"          => ["pic",  0,          [], [ 600,   8],  30, 90, [255,  0],        [],  true, ""],
  "插入背景开始"    => ["pic",  1, [   0,   8], [ 100,   8],  10, 80, [  0, 10], [544,288],  true, "cutin_back"],
  "插入背景结束"    => ["pic",  1,          [],          [],  10, 80, [255, -7], [544,288],  true, ""],
  "白色背景淡入"    => ["pic",  0, [   0,   0], [   0,   0],  50,500, [  0,  6],        [], false, "white"],
  "白色背景淡出"    => ["pic",  0, [   0,   0], [   0,   0],  50,500, [255, -6],        [], false, "white"],
 
 #--------------------------------------------------------------------------
 # ● 状态操作
 #--------------------------------------------------------------------------
  # 对象...[0=自分] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标]
  # 扩展...在上述设定的基础上扩展 [0=无扩展] [1=随机一人] [2=自身除外]
  # 操作...附加状态为"+"，解除状态为"-"
  # 状态ID...将操作的状态ID全部填入数组。
 
  # 附加状态名           判别  对象 扩展 操作 状态ID
  "不能战斗"         => ["sta",  0,   0, "+",  [1]],
 
 #--------------------------------------------------------------------------
 # ● 更改FPS（游戏整体速度） 用于动作的细节检查
 #--------------------------------------------------------------------------
  # 游戏速度...默认为 60 ，数值越低，速度越慢。
 
  # 动作名               判别  游戏速度
  "游戏速度变慢"     => ["fps",  35],
  "游戏速度复原"     => ["fps",  60],
  "游戏速度变快"     => ["fps",  90],
 
 #--------------------------------------------------------------------------
 # ● 更改战斗者图像 将战斗者的图像更改为新的文件
 #--------------------------------------------------------------------------
  # 保持...己方角色是否在战斗后保持图像的更改。
  # 索引...己方角色使用行走图的哪个矩形。
  #        [0][1][2][3]
  #        [4][5][6][7]
  # 文件名...要更改至的图片文件名。角色的文件在 Characters 文件夹，
  #          敌人在 Battlers 文件夹。
  # 脸图...己方角色战斗后是否更改脸图。
  #        更改则填入[脸图索引, 文件名]，不更改则填入 []
 
  # 角色名                 判别     保持    索引      文件名       脸图
  "狼变身"            => ["change", false,    6,    "Animal", [0, "Actor4"]],
 
 #--------------------------------------------------------------------------
 # ● 技能派生 中断动作，派生引发新的技能
 #--------------------------------------------------------------------------
  # 习得...没有学会派生的技能时是否执行。
  # 代价条件...不足以支付派生技能的代价时是否执行。
  # 技能ID...派生技能的ID
 
  # 动作名               判别    习得  代价条件 技能ID
  "多段攻击"         => ["der",  true,  false,   130],
 
 #--------------------------------------------------------------------------
 # ● 播放声音  播放 BGM/BGS/SE
 #--------------------------------------------------------------------------
  # 类别...音效为"se"，BGM为"bgm"，BGS为"bgs"
  # 音调...音调。可以指定为 50～150 之间的数值。默认为 100。
  # 音量...音量。可以指定为 50～150 之间的数值。默认为 100。
  # 文件名...要播放的文件名。设为""表示修改其他设定但不更改 BGM、BGS。
 
  # 动作名             判别      类别  音调 音量  文件名
  "Bow1"          => ["sound",  "se", 100,  80, "Bow1"],
 
 #--------------------------------------------------------------------------
 # ● 播放影像  播放ogv格式的影像
 #--------------------------------------------------------------------------
  # 文件名...要播放的影像文件名。 影像在 Movies 文件夹。
 
  # 动作名                  判别     文件名
  "死亡视频" => ["movie", "sample1"],
 
 #--------------------------------------------------------------------------
 # ● 游戏开关（SideView专用开关）的操作
 #--------------------------------------------------------------------------
  # ID 为正表示操作游戏开关，为负表示操作 Sideview 专用开关
  #
  # ON...把要打开的开关 ID 全部填入数组
  # OFF...把要关闭的开关 ID 全部填入数组
  #
  # 动作名                判别      ON     OFF
  "开关No1/ON"      => ["switch",  [ 1],   []],
  "背景变为宇宙"    => ["switch",  [-4],   []],
  "背景变为宇宙解除"=> ["switch",    [],   [-4]],
  "魔法阵ON"        => ["switch",  [-5],   []],
  "魔法阵OFF"       => ["switch",    [],   [-5]],
 
 #--------------------------------------------------------------------------
 # ● 游戏变量的操作
 #--------------------------------------------------------------------------
  # ID...操作游戏变量的 ID
  # 操作...[0=赋值] [1=加法] [2=减法] [3=乘法] [4=除法] [5=剩余]
  # 运算数...用来进行计算的数值。设为负数的话，会以该数绝对值所对应的变量进行计算。
  #
  # 动作名　  　  判别               ID    操作  运算数
  "变量No1/+1"     => ["variable",   1,     1,     1],
 
 #--------------------------------------------------------------------------
 # ● 条件分歧（游戏开关） 设定条件，使动作发生分歧。
 #--------------------------------------------------------------------------
  # 开关ID...对应开关的 ID。负数则使用 SideView 专用开关。
  # 条件...打开为 true，关闭为 false
  # 分歧...满足条件时的分歧处理。不满足的情况则按照相反方式处理。
  #       [0=执行下一动作] [1=取消下一动作] [2=全动作结束]
  #
  # 动作名                   判别  开关ID  条件  分歧
  "开关No1=ON运行"       => ["n_1",   1,   true,   0],
 
 #--------------------------------------------------------------------------
 # ● 条件分歧 (游戏变量)
 #--------------------------------------------------------------------------
  # 变量ID...对应变量的 ID
  # 数值...填入作为条件的数值。设为负数的话，会以该数绝对值所对应的变量为准。
  # 条件...变量比条件数值...[0=相等] [1=小] [2=大]
  # 分歧...满足条件时的分歧处理。不满足的情况则按照相反方式处理。
  #       [0=执行下一动作] [1=取消下一动作] [2=全动作结束]
  #
  # 动作名                   判别  变量ID  数值  条件  分歧
  "变量No1=1运行"        => ["n_2",   1,    1,    0,    0],
 
 #--------------------------------------------------------------------------
 # ● 条件分歧 (状态)
 #--------------------------------------------------------------------------
  # 对象...检查条件的对象 [0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标]
  # 状态ID...使用几号状态作为条件。
  # 条件...[0=拥有状态] [1=没有状态]
  # 人数...满足以上条件所需人数。条件的对象为多人时，0 表示所有人。
  # 分歧...满足条件时的分歧处理。不满足的情况则按照相反方式处理。
  #       [0=执行下一动作] [1=取消下一动作] [2=全动作结束]
  #
  # 动作名                   判别   对象 状态ID 条件   人数  分歧
  "确认死亡"             => ["n_3",   1,    1,    0,     1,   1],
 
 #--------------------------------------------------------------------------
 # ● 条件分歧 (技能)
 #--------------------------------------------------------------------------
  # 对象...检查条件的对象 [0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标]
  # 技能ID...使用几号技能作为条件。
  # 条件...[0=可以使用] [1=不能使用]
  # 人数...满足以上条件所需人数。条件的对象为多人时，0 表示所有人。
  # 分歧...满足条件时的分歧处理。不满足的情况则按照相反方式处理。
  #       [0=执行下一动作] [1=取消下一动作] [2=全动作结束]
  #
  # 动作名                   判别  对象 技能ID  条件  人数  分歧
  "强击使用可限定"       => ["n_4",  0,   80,    0,    1,   0],
 
 #--------------------------------------------------------------------------
 # ● 条件分歧 (属性)
 #--------------------------------------------------------------------------
  # 对象...检查条件的对象 [0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标]
  # 类别...以哪一项属性作为条件。
  #       [1=Lv] [2=最大HP] [3=最大MP] [4=HP] [5=MP] [6=TP] [7=攻击力]
  #       [8=防御力] [9=魔法攻击] [10=魔法防御] [11=敏捷值] [12=幸运值]
  # 数值...填入作为条件的数值。设为负数的话，表示占对应属性最大值的百分比（仅限HP/MP/TP）
  # 条件...属性和条件数值相比...[0=相等] [1=小] [2=大]
  # 人数...满足以上条件所需人数。条件的对象为多人时，0 表示所有人。
  # 分歧...满足条件时的分歧处理。不满足的情况则按照相反方式处理。
  #       [0=执行下一动作] [1=取消下一动作] [2=全动作结束]
  #
  # 动作名                   判别  对象  类别  数值  条件  人数  分歧
  "HP50%以上运行"        => ["n_5",  0,    4,  -50,    2,    1,   0],
 
 #--------------------------------------------------------------------------
 # ● 条件分歧 (装备)
 #--------------------------------------------------------------------------
  # 对象...检查条件的对象 [0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标]
  # 种类...作为条件的装备种类 [0=武器] [1=防具]
  # 装备ID...对应种类的装备ID。将ID全部填入数组[]中。
  #          负数表示武器（防具）的种类、
  # 条件...[0=装备中] [1=未装备]
  # 人数...满足以上条件所需人数。条件的对象为多人时，0 表示所有人。
  # 分歧...满足条件时的分歧处理。不满足的情况则按照相反方式处理。
  #       [0=执行下一动作] [1=取消下一动作] [2=全动作结束]
  #
  # 动作名                  判别  对象   种类     ID    条件 人数  分歧
  "1号装备限定"          => ["n_6",  0,    0,    [1],    0,    1,   0],
  "拳限定"               => ["n_6",  0,    0,   [-2],    0,    1,   0],
  "拳除外"               => ["n_6",  0,    0,   [-2],    0,    1,   1],
  "弓限定"               => ["n_6",  0,    0,   [-6],    0,    1,   0],
  "弓除外"               => ["n_6",  0,    0,   [-6],    0,    1,   1],
  "拳弓除外"             => ["n_6",  0,    0,[-2,-6],    0,    1,   1],
 
 #--------------------------------------------------------------------------
 # ● 条件分歧 (脚本)　
 #--------------------------------------------------------------------------
  # 分歧...满足条件时的分歧处理。不满足的情况则按照相反方式处理。
  #       [0=执行下一动作] [1=取消下一动作] [2=全动作结束]
  # 脚本...填入返回值为 true 或 false 的脚本
  #
  # 动作名                判别   分歧   脚本
  "50%的概率运行"    => ["n_7",   0,  "rand(100) < 50"],
  "角色限定"         => ["n_7",   0,  "@battler.actor?"],
  "角色ID1限定"      => ["n_7",   0,  "@battler.actor? && @battler.actor_id == 1"],
  "角色ID2限定"      => ["n_7",   0,  "@battler.actor? && @battler.actor_id == 2"],
  "角色ID6限定"      => ["n_7",   0,  "@battler.actor? && @battler.actor_id == 6"],
  "角色ID7限定"      => ["n_7",   0,  "@battler.actor? && @battler.actor_id == 7"],
  "敌人限定"         => ["n_7",   0,  "[email protected]?"],
  "敌人中止"         => ["n_7",   2,  "[email protected]?"],
  "二刀流限定"       => ["n_7",   0,  "@battler.dual_wield?"],
 
 #--------------------------------------------------------------------------
 # ● 第二目标操作
 #--------------------------------------------------------------------------
  # 第二目标是指，与通常的目标相独立的另一目标的信息。
  # 没有操作时，第二目标会设为与通常目标相同。
  #
  # 对象...[0=自分] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标]
  #
  # INDEX...在队伍中的位置（队伍顺序）检索对象 INDEX = [索引, 判别]
  #         索引...队伍中索引值
  #         判别...数值条件 [0=不检索] [1=将该索引设为对象] [2=排除该索引]
  #
  # ID...通过角色（敌人）ID来检索对象。0 表示不检索。
  #      若为负值，则该数的绝对值将会作为排除条件。
  #
  # 状态...以对象当前拥有的状态 ID 作为检索条件。0 表示不检索。
  #        若为负值，则表示检索条件为对象不拥有该状态。
  #
  # 技能...以对象可以使用的技能 ID 作为检索条件。0 表示不检索。
  #        若为负值，则表示检索条件为对象不可使用该技能。
  #
  # 属性...以对象的属性为条件进行检索 属性 = [类别, 数值, 判别]
  #        类别...[1=Lv] [2=最大HP] [3=最大MP] [4=HP] [5=MP] [6=TP] [7=攻击力]
  #               [8=防御力] [9=魔法攻击] [10=魔法防御] [11=敏捷值] [12=幸运值]
  #        数值...填入作为条件的数值。设为负数的话，表示占对应属性最大值的百分比（仅限HP/MP/TP）
  #        判别...属性和条件数值相比...[0=相等] [1=小] [2=大]
  #
  # 装备...以对象的装备进行检索。仅限己方角色。装备 = [种类, ID]
  #       种类...[0=武器] [1=防具]
  #       ID...对应种类的装备ID。将ID全部填入数组[]中。
  #            负数表示武器（防具）的种类、
  #
  # 扩展...在上述设定的基础上扩展 [0=无扩展] [1=随机一人] [2=自身除外]
  # 操作...[0=无操作] [1=将通常目标变更为第二目标] [初开始化第二目标/通常目标]
 
  # 动作名               判别  对象  INDEX  ID  状态 技能   属性        装备   扩展 操作
  "自己以外己方全体"=> ["s_t", 3, [ 0, 0], 0,  0,   0, [ 0, 0, 0], [ 0,[0]],  2,   0],
  "全域化"           => ["s_t", 4, [ 0, 0], 0, -1,   0, [ 0, 0, 0], [ 0,[0]],  0,   1],
 
 #--------------------------------------------------------------------------
 # ● 呼叫公共事件
 #--------------------------------------------------------------------------
  # ID...公共事件ID
  # 等待...在公共事件执行时是否停止动作。
  #
  # 动作名                判别    ID    等待
  "公共事件No1"       => ["common",  1,  true],
 
 #--------------------------------------------------------------------------
 # ● 脚本操作
 #--------------------------------------------------------------------------
  # 执行脚本。把要用 eval 执行的脚本填入范例的 p = 1 处（p = 1 意思是弹出对话框 显示：1）。
  #
  # 脚本名
  "脚本" => ["p = 1 "],
 
 #--------------------------------------------------------------------------
 # ● 其他 无需设定项目即可加入全动作
 #--------------------------------------------------------------------------
  # 战斗动画消去...消除显示中的战斗动画（投掷动画不会消除）
  # 强制战斗结束...强制终止战斗。
  # 画面固定...固定游戏画面。在渐变前加入。
  # 伤害动画...播放技能动画，在动画即将结束时弹出伤害。
  # 反转...翻转图像和武器动画。再次翻转或全动作结束后解除翻转。
  # 武器消去...消除正在显示的武器图像。
  # 武器消去解除...显示已经消除的武器图像。
  # 敌死亡...执行消失效果。主要在敌方无法战斗时使用。
  # 死亡禁止...对象的HP为 0 时禁止死亡效果。可用于连续攻击开始之类的地方。
  # 死亡禁止解除...解除死亡禁止。可用于连续攻击结束之类的地方。即使不用这一条，行动结束时也会允许消失效果。
  # 待机无效...暂停待机动作。可用于战斗事件之类的地方。
  # 待机无效解除...解除待机无效，进行待机动作。
  # 初期位置变更...将原来的坐标（初开始位置）变更为现在的坐标。
  # 初期位置变更解除...恢复初期位置变更改变的坐标。
  # 强制...强制下次行动的目标（反作用）
  # 强制2...强制下次行动的第二目标（反作用）
  # 下一个行动者...视为战斗行动结束，立刻开始下一角色的行动。
  # 单个开始...单独处理多个目标的攻击时，重复行动开始的记号。
  # 单个结束...单独处理多个目标的攻击时，重复行动结束的记号。
  # 循环开始...不断重复"循环开始"与"循环结束"之间的行动。
  # 循环结束...不断重复"循环开始"与"循环结束"之间的行动。
 
  # 动作名                  判别
  "战斗动画消去"      => ["anime_off"],
  "强制战斗结束"      => ["battle_end"],
  "画面固定"          => ["graphics_freeze"],
  "伤害动画"          => ["damage_anime"],
  "反转"              => ["mirror"],
  "武器消去"          => ["weapon_off"],
  "武器消去解除"      => ["weapon_on"],
  "敌死亡"            => ["normal_collapse"],
  "死亡禁止"          => ["no_collapse"],
  "死亡禁止解除"      => ["collapse"],
  "待机无效"          => ["non_motion"],
  "待机无效解除"      => ["non_motion_cancel"],
  "初期位置变更"      => ["change_base_position"],
  "初期位置变更解除"  => ["set_base_position"],
  "强制"              => ["force_action"],
  "强制2"             => ["force_action2"],
  "下一个行动者"      => ["next_battler"],
  "单个开始"          => ["individual_start"],
  "单个结束"          => ["individual_end"],
  "循环开始"          => ["loop_start"],
  "循环结束"          => ["loop_end"],
 
 #--------------------------------------------------------------------------
 # ● 等待 到下个行动前的等待时间
 #--------------------------------------------------------------------------
  # 当动作名只有数字时，该数字即为等待的时间。
  #（例） "20"...等待 20 帧进入下一动作。
  #
  # 数值为负表示等待时间为 0～绝对值 之间的一个随机数。
  #（例） "-20"...随机等待 0～20 帧。
 
 #--------------------------------------------------------------------------
 # ● 快捷指令
 #--------------------------------------------------------------------------
  # 一般来说，把动作名写入全动作数组才可以完成行动的制作。
  # 其实也可以不设定动作，直接以描述指令，可以减少作业量。
  # 频繁使用快捷方式可以减少记录的动作数量，因此推荐使用。
  #
  # [战斗动画]
  # (例) "anime(20)" ... 在目标上执行数据库中 20 号的动画（有等待）
  # (例) "anime(20,false)" ...在目标上执行数据库中 20 号的动画（无等待）
  # (例) "anime_me(20)" ...自身执行数据库中 20 号的动画（有等待）
  # (例) "anime_me(20,false)" ...自身执行数据库中 20 号的动画（无等待）
  #
  # [等待 按索引延迟] ※ 根据角色在队伍中的索引，给等待加上延迟。
  # (例) "delay(12)"...1号队员等待 0 帧 2号队员等待12帧 3号队员等待24帧...
  #
  # [音效(SE)]
  # (例) "se('Bow1')" ...播放文件名名为Bow1的SE。
  # (例) "se('Bow1',50)" ...音量设为 50，播放文件名名为Bow1的SE。
  #
  # [强制目标动画（全动画）]
  # (例) "target('伤害的硬直')" ...强制目标执行"伤害的硬直"动作
  # (例) "target2('被伤害')" ...强制第二目标执行"被伤害"动作
 
  }
#==============================================================================
# ■ 全动作
#------------------------------------------------------------------------------
#   将动作组合起来，从左到右顺次执行。
#   全动作中可以加入全动作，可以方便动作的元件化、条件分歧后放入全动作等方面。
#==============================================================================
  FULLACTION = {
 
  # 待机系
  "通常待机"        => ["待机"],
  "通常待机固定"    => ["待机固定WT"],
  "危机待机"        => ["状态异常/危机","危机色调","待机","待机"],
  "防御待机"        => ["待机固定WT"],
  "毒待机"          => ["状态异常/通用","毒色调","待机","待机","敌人限定","80"],
  "睡眠待机"        => ["状态异常/睡眠","敌人限定","40","敌人中止","死亡","死亡"],
  "通用状态异常待机"=> ["状态异常/通用","通用状态异常色调","待机","待机","敌人限定","80"],
  "观望"            => ["待机","60"],
  "无法战斗"        => ["死亡"],
 
  # 系统系
  "战斗开始己方"    => ["战斗前己方配置","delay(4)","坐标复位向左"],
  "己方退场"        => ["退场"],
  "逃走"            => ["对象动画","镜头复位","delay(4)","退场"],
  "敌逃走"          => ["对象动画","逃走透明","退场"],
  "逃走失敗"        => ["镜头复位","delay(4)","逃走途中","一步后移动","坐标复位向左"],
  "命令输入"        => ["战斗动画消去","命令输入移动"],
  "命令输入结束"    => ["坐标复位早"],
  "命令后防御"      => ["待机固定WT"],
  "命令后魔法"      => ["待机固定","魔法吟唱中"],
  "命令后特技"      => ["待机固定","特技待机中"],
  "防御"            => ["对象动画","待机固定WT"],
  "回避"            => ["角色限定","右1旋转","一步后跳跃","10","坐标复位向左"],
  "盾格挡"          => ["se('Evasion2')","盾防御","60"],
  "替身开始"        => ["敌中移动早","初期位置变更"],
  "替身结束"        => ["初期位置变更解除","坐标复位向左"],
  "被替身开始"      => ["一步后移动","一步后移动","待机固定WT"],
  "被替身结束"      => ["坐标复位向左"],
  "胜利姿态挥动"    => ["战斗动画消去","胜利跳跃武器","胜利跳跃着地","120"],
  "胜利姿态后空翻"  => ["战斗动画消去","右1旋转","胜利跳跃","拳限定","武器出拳","拳除外","武器挥动R","120"],
  "闪光"            => ["anime_me(119)","20"],
 
  # 反作用系
  "被伤害"          => ["伤害的硬直","坐标复位向左"],
  "被伤害大"        => ["震动中","伤害的硬直大","坐标复位向左"],
  "纵晃动"          => ["纵晃动01","纵晃动02","纵晃动01","纵晃动02","纵晃动01","纵晃动02"],
 
  # 快捷方式系（给其它全动作中调用）
  "斩"              => ["武器挥动R","对象动画武器","10"],
  "拳"              => ["武器出拳","对象动画武器","10"],
  "弓"              => ["Bow1","弓射击","箭发射","9"],
  "攻击"            => ["拳限定","拳","弓限定","弓","拳弓除外","斩"],
  "通常攻击开始"    => ["敌前移动","死亡禁止","单个开始","二刀流限定","二刀左"],
  "通常攻击结束"    => ["确认死亡","对象动画武器WT","单个结束","死亡禁止解除","下一个行动者","坐标复位曲线"],
  "二刀左"          => ["武器挥动L","对象动画武器LWT"],
  "特技发动"        => ["一步向前移动","武器拿出","特技发动动画"],
  "魔法发动"        => ["一步向前移动","武器拿出","魔法发动动画"],
  "插入"            => ["插入背景开始","插入分歧","70","插入終","插入背景结束","20"],
  "插入分歧"        => ["角色ID1限定","插入A1","角色ID2限定","插入A2","角色ID6限定","插入A3","角色ID7限定","插入A4"],
  "死亡フラグ動画"  => ["白色背景淡入","50","死亡视频","白色背景淡出","50"],
  "背景宇宙"        => ["缩小","se('Blind',70)","背景变暗","自己以外己方全体","强制2","透明化","透明化","40","背景变为宇宙","色调初始化"],
  "背景宇宙解除"    => ["镜头复位","背景变暗","target2('透明化解除WT')","透明化解除","40","背景变为宇宙解除","色调初始化"],
  "魔法阵表示"      => ["se('Blind',70)","画面固定","魔法阵ON","圆圈"],
  "魔法阵消去"      => ["40","画面固定","魔法阵OFF","圆圈"],
 
  # 普通攻击系
  "通常攻击"        => ["通常攻击开始","待机固定","通常攻击结束"],
  "斩攻击"          => ["通常攻击开始","确认死亡","武器挥动R","通常攻击结束"],
  "拳攻击"          => ["通常攻击开始","武器出拳","通常攻击结束"],
  "刺攻击"          => ["通常攻击开始","武器刺","通常攻击结束"],
  "弓攻击"          => ["一步向前移动","死亡禁止","单个开始","Bow1","弓射击",
                        "箭发射WT","单个结束","死亡禁止解除","坐标复位"],
 
  # 技能系
  "通用特技"        => ["特技发动","武器挥动R","伤害动画","坐标复位"],
  "通用魔法"        => ["魔法发动","武器挥动R","伤害动画","坐标复位"],
 
  "水枪"            => ["特技发动","武器挥动R","水枪发射","坐标复位"],
  "武器投掷"        => ["特技发动","Bow1","武器挥动R","6","待机固定","武器投掷开始","武器投掷返回","坐标复位"],
  "插入图片攻击"        => ["特技发动","插入","攻击","坐标复位"],
  "影像攻击"        => ["特技发动","待机固定","死亡フラグ動画","通常攻击开始","武器挥动R","通常攻击结束"],
  "狼人变身"        => ["特技发动","anime(110,false)","狼变身","待机固定","120","坐标复位"],
  "5回攻击"         => ["特技发动","死亡禁止","弓除外","敌前移动","攻击","攻击","攻击","攻击","攻击","死亡禁止解除","坐标复位"],
  "特技派生"        => ["武器投掷","多段攻击","斩攻击"],
  "背景变更攻击"    => ["魔法发动","武器挥动R","背景宇宙","伤害动画","背景宇宙解除","坐标复位"],
  "图片攻击"        => ["魔法发动","魔法阵表示","武器挥动R","anime(80,false)","60","震动大","对象动画","魔法阵消去","坐标复位"],
  "变暗攻击"        => ["特技发动","除自己以外全变暗","se('Laser',150)",
                        "残像ON","敌前移动","anime(35,false)","敌后移动","对象动画",
                        "武器挥动R","20","色调初始化","坐标复位","残像OFF"],
  "空中攻击"        => ["特技发动","Bow1","一步前跳跃","杖打击前跳跃",
                        "待机固定","左1旋转","10","anime(117,false)","杖打击",
                        "对象动画","震动中","强制","纵晃动","20",
                        "一步后跳跃","坐标复位"],
 
  # 道具系
  "使用物品"     => ["敌前移动","待机固定","对象动画WT","坐标复位向左"],
 
 
 
  }
 
 
 
#==============================================================================
# ■ 战斗程序
#------------------------------------------------------------------------------
#   对战斗场景的演出进行时间管理
#   通过游戏开关、SideView专用开关进行控制
#==============================================================================
  BATTLE_PROGRAM = {
 
 #--------------------------------------------------------------------------
 # ● 开关控制  通过开关的时间操作来控制演出
 #--------------------------------------------------------------------------
  # 开关...作为执行程序的信号的游戏开关ID。设为负数则使用 SideView 专用开关。
  #        开关关闭后，执行中的程序将会终止。
  #        SideView 专用开关在战斗结束后会初开始化（全部关闭）
  #        若要在事件中操作 SideView 专用开关，
  #        请执行事件脚本 $sv_camera.switches[1] = true
  #        (1 为操作的开关 ID，打开则设为 true，关闭则设为 false)
  #
  # ON...打开的开关ID。设为负数则使用 SideView 专用开关。
  #      将 ID 全部填入数组中。
  #      例...[1,2,-5] 打开游戏开关 1、2 以及 SideView 专用开关 5
  #
  # OFF...关闭的开关ID。设为负数则使用 SideView 专用开关。
  #       不需要操作时填入 []
  #
  # 时间...执行上述开关操作所需要的时间（单位为帧）
  #        若设为 100，从程序开始 100 帧后执行开关操作
  #        [参考值] 30秒...1800　1分钟...3600　5分钟...18000 10分钟...36000　1小时...216000
  #
  # 随机范围...加进时间的随机值的范围，单位为帧
  #            比如时间300，随机范围300的话，最终的时间将会是 300～600 帧。
 
  # 名称                判别     开关    ON       OFF   时間  随机范围
  "背景变堡垒"       => ["switch",  -1,   [-2],      [],  1200,     0],
  "背景变海"         => ["switch",  -2,   [-3],      [],  2400,     0],
 
 #--------------------------------------------------------------------------
 # ● 播放 SE/BGM/BGS
 #--------------------------------------------------------------------------
  #
  # 开关...作为执行程序的信号的游戏开关ID。设为负数则使用 SideView 专用开关。
  #
  # 类别...音效为"se"，BGM为"bgm"，BGS为"bgs"
  # 音调...音调。可以指定为 50～150 之间的数值。默认为 100。
  # 音量...音量。可以指定为 50～150 之间的数值。默认为 100。
  # 文件名...要播放的文件名。设为""表示修改其他设定但不更改 BGM、BGS。
 
  # 名称                 判别   开关  类别   音调  音量 文件名
  "海浪声"            => ["sound",  -1, "bgs",  100,  80, "Sea"],
 
 #--------------------------------------------------------------------------、
 # ● 背景的控制 执行更改图片、自动滚动
 #--------------------------------------------------------------------------
  # 开关...作为执行程序的信号的游戏开关ID。
  # No....所操作的背景的序号。1为地板背景，2为墙壁背景（远景）
  #
  # 滚动速度...背景移动的速度。[X轴, Y轴]
  #            单位为每 100 帧移动的像素数。
  #            要高速移动，请使用 1000 的数量级。
  #
  # BA翻转...被偷袭时背景的X坐标滚动是否反向。图像不会翻转。
  #
  # 图像...如果想要更改背景图，就填入文件名，否则填入 ""
  #        地板背景在 Battlebacks1 文件夹，墙壁背景在 Battlebacks2 文件夹。
  #        更改后的背景设定会继承更改前的设定。
  #
  # 中间图...为了使滚动背景时，背景的更改变得更加自然，所需要的中间图的文件名。
  #          如果滚动过程中背景发生了更改，会在滚动结束后再更改。
  #
  # 插入...显示此背景时是否允许其他背景控制的插入。
  #        允许则填 true（中间图显示时，只有没有滚动的背景可以插入）
  #        不允许则填 false（保留其他的背景控制，直到该背景结束时再进行更改）
 
  # 名称                判别   开关  No.   滚动速度    BA翻转   图像        中间图        插入
  "远景向右移动"  => ["scroll", -1,  1, [  40,    0],  true,  "",                 "",  true],
  "海背景3变更"   => ["scroll", -2,  1, [ 120,    0],  true,  "Sea_ex03", "Sea_ex02",  true],
  "海背景4变更"   => ["scroll", -3,  1, [  40,    0],  true,  "Sea_ex01", "Sea_ex04",  true],
  "宇宙变更1"     => ["scroll", -4,  1, [   0,    0],  true,  "DarkSpace",        "", false],
  "宇宙变更2"     => ["scroll", -4,  2, [   0,    0],  true,  "DarkSpace",        "", false],
 
 #--------------------------------------------------------------------------
 # ● 周期图像 周期性地操作瓷砖状的图片。比如风和巨大魔法阵。
 #--------------------------------------------------------------------------
  # 开关...作为执行程序的信号的游戏开关ID。
  # No....操作的图片编号。显示图片的数量没有限制。
  # 移动速度...每 100 帧图片移动的速度。[X轴, Y轴]。0 表示与背景滚动同步。
  # 时限...该程序执行的时限。单位为帧。设为 0 表示不断循环。
  #
  # 透明操作...图片的透明度操作。[开始透明度, 每 100 帧增加的透明度]
  #            透明度达到 255 时会回到开始的透明度，再重复这样的过程。
  # Z轴...图片的 Z 坐标。设为 100 以上则显示在窗口前方。
  # 允许震动...是否允许与震动动作的震动联动。
  # BA翻转...被偷袭时图片的X坐标滚动是否反向。图像不会翻转。
  # 文件名...图片的文件名。文件在 Pictures 文件夹里。
 
  # 名称             判别   开关  No.   移动速度     时限    透明操作   Z轴    允许震动 BA翻转 文件名
  "风"            => ["kpic", -1,  0, [  500,    0],    0, [ 255,   0],  90,   false,  true, "back_wind"],
  "魔法阵"        => ["kpic", -5,  1, [    0,    0],    0, [ 255,   0],  90,    true,  true, "magic_square01"],
 
 #--------------------------------------------------------------------------
 # ● 周期 SE  周期性地响起音效。比如雷鸣、波涛的声音。
 #--------------------------------------------------------------------------
  # 开关...作为执行程序的信号的游戏开关ID。
  # 周期...响起音效的周期。单位为帧。以此为间隔，音效会定期响起。
  # 随机范围...加在周期里的随机范围。单位为帧。
  #
  # 音调...音调。可以指定为 50～150 之间的数值。默认为 100。
  # 音量...音量。可以指定为 50～150 之间的数值。默认为 100。
  # 开始执行...程序执行之后，是否不等待一个周期直接响起音效。
  # 文件名...播放的文件名。
 
  # 名称               判别     开关 周期  随机范围 音调 音量 开始执行   文件名
  "海鸥"         => ["keep_se", -1,  400,    100,  150,  60,  false,  "Crow"],
  "海鸥2"        => ["keep_se", -1,  300,    200,  140,  45,   true,  "Crow"],
 
 #--------------------------------------------------------------------------
 # ● 周期震动  周期性地震动画面
 #--------------------------------------------------------------------------
  # 开关...作为执行程序的信号的游戏开关ID。开关打开时效果开始。
  # 周期...画面震动的周期。单位为帧。
  # 随机范围...加在周期里的随机范围。单位为帧。
  #
  # 方向...震动的方向 [横, 纵]。数值越大，振幅越大。
  # 速度...震动的速度。数值越小，震动越快。
  # 时间...震动的持续时间。震幅会随着时间逐渐减小、
  # 开始执行...程序执行之后，是否不等待一个周期直接开始震动。
 
  # 程序名                判别    开关 周期 随机范围   方向  速度  时间 开始执行
  "船的晃动"       => ["keep_sk", -1,  130,    0,  [  0, 4], 80,  120,  true],
 
 #--------------------------------------------------------------------------
 # ● 周期更改色调  周期性地更改画面的色调
 #--------------------------------------------------------------------------
  # 开关...作为执行程序的信号的游戏开关ID。开关打开时效果开始。
  # 周期...更改色调的周期。单位为帧。
  # 随机范围...加在周期里的随机范围。单位为帧
  #
  # 对象...更改色调的对象 [0=背景] [1=敌方全体] [2=己方全体] [3=双方全体] [4=全部]
  # 色调...[ R, G, B, alpha（颜色强度）, 更改时间, ※返回]
  #        ※返回...更改完成后回到原来的颜色所需要的时间。不还原的话填入 0。
  # 开始执行...程序执行之后，是否不等待一个周期直接更改色调。
 
  # 程序名       判别   开关   周期 随机范围 对象    R,   G,   B,  alpha 时间 返回  开始执行
  "雷光"     => ["keep_c",  0,  300,  100,     4,  [ 255, 255, 255, 255,   8,   8],  true],
  "紧急情况" => ["keep_c",  0,  150,    0,     4,  [ 255,   0,   0, 100,  40,  40],  true],
 
}
#==============================================================================
# ■ 镜头设定
#------------------------------------------------------------------------------
#   除了动作外，其他战斗场景的各个点上均有镜头。
#   由于动作名会移动镜头，请不要改变名字。
#==============================================================================
  BATTLE_CAMERA = {
 #--------------------------------------------------------------------------
 # ● 镜头镜头  进行画面的缩放、滚动
 #--------------------------------------------------------------------------
  # 对象...移动、缩放的对象 [2=敌方全体] [3=己方全体] [4=双方全体] [6=画面]
  # 调整坐标...微调镜头坐标的最终地点 [X轴（正数为右）, Y轴（正数为下）]
  # 时间...镜头动作所需时间
  # 缩放...镜头的缩放率(%)。100 表示无缩放。
 
  # 动作名              判别     对象   调整坐标   缩放 时间
  "转身开始前"   => ["camera",   6, [  40,   0],  95, 40],
  "转身开始后"   => ["camera",   6, [   0,   0], 100, 40],
  "战斗结束时"     => ["camera",   6, [ 100,   0], 100, 50],
 
 
}
end

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


# ■ SideView 动作設定 Ver100


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


#  SideView 战斗总体设置、生成动作


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


module N03


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


 # ● 全体设定


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


  # 角色初始位置　        第一位       第二位       第三位       第四位


  #                    X轴 Y轴 H轴  X轴 Y轴 H轴  X轴 Y轴 H轴  X轴 Y轴 H轴


  ACTOR_POSITION   = [[415,160, 0],[435,185, 0],[455,210, 0],[475,235, 0]]


  # 行动结束时的等待时间（单位：帧）


  ACTION_END_WAIT = 8


  # 回合结束时的等待时间（单位：帧）


  TURN_END_WAIT = 12


  # 被敌人偷袭时，角色是否左右翻转。是：true；不是：false（下同）


  BACK_ATTACK = true


  # 队友受到伤害时，是否使用默认效果。


  ACTOR_DAMAGE = false


  # 敌方受到伤害时，是否使用默认效果。


  ENEMY_DAMAGE = false


  # 敌方战斗者的 X 坐标、计算旋转、战斗动画是否自动翻转。


  ENEMY_MIRROR = true


  # 用于禁止消失效果处理的，数据库中不死之身的状态 ID


  IMMORTAL_ID = 10


 


  # 是否显示战斗日志


  # 填入 false 时，会在画面上方显示技能名的窗口


  BATTLE_LOG = true


  # 技能名窗口打开时，将不需要表示的技能 ID 填入数组


  NO_DISPLAY_SKILL_ID = [1,2,3,4,5,6,7]


  # 是否弹出伤害数字


  DAMAGE_POP = true


  # 是否弹出附加状态


  STATE_POP = true


  # 伤害数字图片的文件名（参考System文件夹）


  DAMAGE_PLUS = "damage_num+"


  # 回复数字图片的文件名（参考System文件夹）


  DAMAGE_MINUS = "damage_num-"


  # MP 伤害数字图片的文件名（参考System文件夹）


  DAMAGE_MP = "damage_mp"


  # TP 伤害数字图片的文件名（参考System文件夹）


  DAMAGE_TP = "damage_tp"


  # 调整伤害数字之间的文字间距


  DAMAGE_ADJUST = -4


 


  # 调整战斗镜头的焦点 [X轴, Y轴]


  CAMERA_POSITION = [   0, -40]


 


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


 # ● 设置战斗背景 设定背景的坐标调整和放大率


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


  # 地板背景文件名...设定的地板背景图像文件名。


  #                 "全Battlebacks1"为未设定的Battlebacks1图像的默认值。


  # 墙壁背景文件名...设定的墙壁背景图像文件名。


  #                 "全Battlebacks2"为未设定的Battlebacks2图像的默认值。


  # 坐标调整...[X轴, Y轴]


  # 放大率...[横向, 纵向]


  # 允许震动...在震动动作中是否允许晃动。


  # 触发开关...开始战斗时自动打开的游戏开关 ID。设为负数则打开 SideView 专用开关。


  #           在想要集中管理背景和战斗程序的时候使用。


  #           不需要操作开关的话设为 0


 


   FLOOR1_DATA = {


 # 地板背景文件名             坐标调整      放大率    允许震动  触发开关


  "Sea_ex01"              => [ [   0, 120], [ 150, 150], false,   -1],


  "全Battlebacks1"        => [ [   0, 120], [ 150, 150],  true,    0],


 


  }


   FLOOR2_DATA = {


 # 墙壁背景文件名             坐标调整      放大率    允许震动  触发开关


  "Ship_ex"               => [ [   0, 120], [ 150, 150],  true,    0],


  "全Battlebacks2"        => [ [   0, 120], [ 150, 150],  true,    0],


 


 


}


 


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


# ■ 动作


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


#   战斗者在战斗中的一次行动。组合起来成为全动作


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


 # 这里的动作名和全动作名请不要重复。


  ACTION = {


 


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


 # ● 战斗动画設定


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


  # 默认的行走套图是一个图片文件中设定了多名角色。


  # 使用行走套图的时候，追加图像请与角色的图像设定对应。


  # 角色与图像一一对应（文件名有 $ 前缀）时没有这个问题。


 


  # 索引...使用的战斗者图像文件后缀的索引名。


  #        SideView 的战斗者若为己方角色，会以角色行走图的文件名为准。


  #        带上索引后则会以 角色行走图文件名+索引名 的图像文件为准。


  #        例) Actor1 战斗者执行索引为"_1"的动画时，使用的文件名为 Actor1_1


  #        使用行走套图的时候，动画的索引名会为 ""


  #        角色的图像放进 Characters 文件夹，敌人的图像放进 Battlers 文件夹。


  #


  # 纵元...图像文件元件的纵向位置。从上往下分别为 0～3。数量上没有限制。


  #          元件数的设定在战斗者设定中。


  # 横元...动画开始播放的图像文件元件的横向位置。从左往右分别为 0～3。


  #          动画从这一元件开始从左向右播放。元件数量没有限制。


  # 模式... 0:元件固定 1:单向 2:反复 3:单向循环 4:反复循环


  # 速度...动画的更新速度。数字越小，更新越快。


  # Z轴...画面越前方数值越大。通常情况会显示在画面下方。


  # 等待...是否动画播放到最后再展开下一个行动。


  # 影子...是否显示影子的图像


  # 武器...如果要显示武器，天上武器的动作名，否则填入""。


  #        武器可以同时添加任意多个。添加的部分填在数组的后方。


 


  # 动作名（待机系）      判别     索引   纵元 横元 模式 速度  Z轴  等待 影子 武器


  "待机"            => ["motion",   "",    1,   0,   4,   12,   0, true, true, "" ],


  "待机固定WT"      => ["motion",   "",    1,   1,   0,   12,   0, true, true, "" ],


  "待机固定"        => ["motion",   "",    1,   1,   0,   12,   0,false, true, "" ],


  "死亡"            => ["motion", "_1",    0,   0,   0,   12,   0, true,false, "" ],


  "向右"            => ["motion",   "",    2,   0,   4,   12,   0, true, true, "" ],


 


  # 动作名（移动系）      判别      索引  纵元 横元  模式 速度  Z轴 等待  影子  武器


  "向左移动"         => ["motion",   "",    1,   0,   4,    6,  10, true, true, "" ],


  "向右移动"         => ["motion",   "",    2,   0,   4,    6,  10, true, true, "" ],


 


  # 动作名（静止系）      判别      索引  纵元 横元 模式 速度 Z轴  等待  影子   武器


  "武器拿出"        => ["motion",   "",    1,   0,   1,    2, 200,false, true, "拿出" ],


 


  # 动作名（攻击系）      判别     索引  纵元 横元 模式  速度 Z轴  等待  影子  武器


  "武器挥动R"       => ["motion",   "",    1,   0,   1,    2, 200,false, true, "纵挥动"],


  "武器挥动L"       => ["motion",   "",    1,   0,   1,    2, 200,false, true, "纵挥动L"],


  "武器挥动LR"      => ["motion",   "",    1,   0,   1,    2, 200,false, true, "纵挥动","纵挥动L"],


  "盾防御"          => ["motion",   "",    1,   0,   1,    2, 200,false, true, "盾"],


  "武器出拳"        => ["motion",   "",    1,   0,   1,    2, 200,false, true, "出拳" ],


  "武器刺"          => ["motion",   "",    1,   0,   1,    2, 200,false, true, "刺" ],


  "弓射击"          => ["motion",   "",    1,   0,   1,    2, 200,false, true, "弓"],


 


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


 # ● 战斗者的移动 敌人的 X 方向移动会自动反向计算


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


  # 目标...移动至目标坐标的参照对象。数值为正则参照现在位置，数值为负则参照初开始位置（[0=自身]无法设定为负，因此用 -7 表示）


  #       [0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标] [6=画面]


  # X轴...对象看到的X坐标


  # Y轴...对象看到的Y坐标


  # H轴...对象看到的H坐标（从地面算起的高度）。设置为 nil 则无视 H轴，只在 XY 方向移动。


  # 速度...每帧移动的像素数。负数表示指定时间，即移动完成耗费的总帧数。


  # 曲线...设为正数则向上，负数则向下弯曲。


  # 跳跃...跳跃的抛物线轨道。[从开始跳跃至顶点的轨道, 从顶点开始直到落地的轨道]


  # 动画...在移动中使用的战斗者动画的动作名。


 


  # 动作名（系统系）         判别  目标 X轴  Y轴  H轴 速度 曲线    跳跃     动画


  "战斗前己方配置"     => ["move",-7, 180,   0,   0,  0,   0, [  0,  0], "向左移动"],


  "退场"               => ["move",-7, 180,   0,   0,  7,   0, [  0,  0], "向右移动"],


  "逃走途中"           => ["move",-7,  80,   0,   0,  7,   0, [  0,  0], "向右移动"],


  "命令输入移动"       => ["move",-7, -20,   0, nil,-10,   0, [  0,  0], "向左移动"],


  "伤害的硬直"         => ["move", 0,  20,   0, nil,-10,   0, [  0,  0], ""],


  "伤害的硬直大"       => ["move", 0,  60,   0, nil,-10,   0, [  0,  0], ""],


 


  # 动作名（重置系）         判别  目标 X轴  Y轴  H轴 速度 曲线    跳跃     动画


  "坐标复位早"          => ["move",-7,   0,   0,   0,-10,   0, [  0,  0], "向右移动"],


  "坐标复位"            => ["move",-7,   0,   0,   0,-20,   0, [  0,  0], "向右移动"],


  "坐标复位曲线"        => ["move",-7,   0,   0,   0,-20,  -2, [  0,  0], "向右移动"],


  "坐标复位向左"        => ["move",-7,   0,   0,   0,-20,   0, [  0,  0], "向左移动"],


 


  # 动作名（自身系）         判别  目标 X轴  Y轴  H轴 速度 曲线    跳跃     动画


  "一步向前移动"        => ["move", 0, -20,   0,   0,-10,   0, [  0,  0], "向左移动"],


  "一步后移动"          => ["move", 0,  20,   0,   0,-10,   0, [  0,  0], "向左移动"],


  "一步前跳跃"          => ["move", 0, -30,   0,   0,-10,   0, [ 20,-20], "向左移动"],


  "一步后跳跃"          => ["move", 0,  30,   0,   0,-10,   0, [ 20,-20], "向左移动"],


  "胜利跳跃"            => ["move", 0,  10,   0,   0,-25,   0, [ 30,-30], "待机固定"],


  "胜利跳跃武器"        => ["move", 0,   0,   0,   0,-15,   0, [ 20,  0], "武器拿出"],


  "胜利跳跃着地"        => ["move",-7,   0,   0,   0,-10,   0, [  0,  0], "武器挥动R"],


  "纵晃动01"            => ["move", 0,   0,   0,  20, -2,   0, [  0,  0], ""],


  "纵晃动02"            => ["move", 0,   0,   0, -20, -2,   0, [  0,  0], ""],


 


  # 动作名（目标系）         判别  目标 X轴  Y轴  H轴 速度 曲线    跳跃     动画


  "敌前移动"            => ["move", 1,  30,   0,   0,-20,   0, [  0,  0], "向左移动"],


  "敌后移动"            => ["move", 1, -60,   0,   0,-20,   0, [  0,  0], "向左移动"],


  "敌中移动早"          => ["move", 1,   0,   0,   0,-10,   0, [  0,  0], "向左移动"],


  "杖打击前跳跃"        => ["move",-1,   0,   0, 100,-20,   0, [ 40,-20], "武器拿出"],


  "杖打击"              => ["move",-1,   0,   0,   0,-10,   0, [  0,  0], "武器挥动R"],


 


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


 # ● 武器动作 战斗者动画以及武器・投掷动画中使用的动作


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


  # 类型...[0...使用图标]


  #        [1...使用独立图像（图像名设置位于战斗者设定的武器项目。参照目标为 Characters 文件夹）]


  #        [2...动画元件（※2003规格。动画的元件数与战斗者相同。图像名设置位于战斗者设定的武器项目。参照目标为 Characters 文件夹）]


  # 移动...图片移动的距离。[X轴, Y轴]


  # 调整...图片微调的初开始坐标。[X轴, Y轴]


  # 开始度...动作前的角度。按照逆时针计算，0～360° 。 填入负数则为顺时针。


  # 终度...动作后的角度


  # 原点...图像的原点。[0...中心] [1...左上] [2...右上] [3...左下] [4...右下] [5...和战斗者相同（图像的下半部分）]


  # 翻转...图像是否翻转


  # 放大...[X轴放大率, Y轴放大率]。接受小数。


  # Z轴...图像是否显示在角色前方


  # 反手...盾图像，或者二刀流时显示左手武器。


  #        不使用图标时，盾的图像会按照战斗者设定的盾的项目来运行。


  #


  # 更新...设为-1则与战斗者动画同步更新。要特殊设置，设定为[更新时间间隔, 更新图案数目, 是否循环]


  #


  # 索引...本来会武器图像依据装备的武器（盾）上设定的图像文件名。


  #        在此加上索引后，则会依据 图像文件名+索引名 的图像。


  #        适用于同一武器有多种模式的图像的场合。


  #        例）"纵挥动"的索引为"" => 图像文件名为"IconSet"


  #        例）"纵挥动2"的索引为"_1" => 图像文件名为"IconSet_1"


  #        如果使用图标，则文件夹为 System 文件夹；如果使用独立画像或动画元件，则文件夹为 Characters 文件夹。


  #


  # 图像...想要无视武器和盾设定的图像文件和索引名，直接指定武器图像时，


  #        在这里填入图像文件名。图像放入 Characters 文件夹。


 


  # 动作名        判别 类型  移动     调整    开始度  终度 原点  翻转   拡大    Z轴   反手   更新   索引    图像


  "纵挥动"    => ["wp", 0,[  6, 0],[ -4,-10], -45,  45,  4, false, [1,1], false, false,   -1,   "",    ""],


  "盾"        => ["wp", 0,[  0, 0],[ 12,  0],   0,   0,  4, false, [1,1],  true,  true,   -1,   "",    ""],


  "纵挥动L"   => ["wp", 0,[  6, 0],[  0, -8],-135,  45,  4, false, [1,1],  true,  true,   -1,   "",    ""],


  "出拳"      => ["wp", 0,[-20, 0],[  5,  5], -45, -45,  4, false, [1,1], false, false,   -1,   "",    ""],


  "刺"        => ["wp", 0,[-25, 0],[ 25,-10],  45,  45,  4, false, [1,1], false, false,   -1,   "",    ""],


  "拿出"      => ["wp", 0,[  6,-4],[ -4,-10],  90, -45,  4, false, [1,1], false, false,   -1,   "",    ""],


 


  # 2003规格      判别 类型  移动     调整    开始度  终度 原点  翻转   拡大    Z轴   反手   更新   索引    图像


  "弓"        => ["wp", 2,[  0, 0],[  0,  0],   0,   0,  5, false, [1,1],  true, false,   -1,   "",    ""],


 


  # 投掷武器用    判别 类型  移动     调整    开始度  终度 原点  翻转   拡大    Z轴   反手      更新       索引    图像


  "箭"        => ["wp", 0,[  0, 0],[  0,  0],   0,  45,  0, false, [1,1],  true, false,[2,6,false],   "",    "arrow01"],


  "旋转"      => ["wp", 0,[  0, 0],[  0,  0],   0, 360,  0, false, [1,1],  true, false,[1,8, true],   "",    ""],


 


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


 # ● 投掷武器・道具 能使武器和战斗动画移动。用于飞行道具中。


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


  # ID...数据库中的动画ID。[要移动的动画 ID，打击时的动画 ID] 0 为不显示动画，-1 为显示武器动画。


  # 开始...动画开始移动的位置。设为负数，则即使有多个目标，也只显示一个动画。


  #     [0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标] [6=画面]


  # 末...动画结束移动的位置。设为负数，则即使有多个目标，也只显示一个动画。


  #     [0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标] [6=画面]


  # 开始调整...微调开始移动的坐标。[X轴, Y轴]。敌人的X轴会自动反向计算。


  # 末调整...微调结束移动的坐标。[X轴, Y轴]。敌人的X轴会自动反向计算。


  # 速度...每帧在X轴上移动的像素数。设为负数则按照时间设定，速度会根据距离而改变。


  # 类型...移动后的处理。[0=消失（未命中时自动变为穿透）] [1=穿透] [2=消失（未命中时也会消失）]


  # 轨道...移动的轨道。[从开始直至顶点的轨道, 从顶点开始直到落地的轨道]


  # Z轴...动画和武器是否显示在角色前方。


  # 等待...是否直到该动作结束后才转到下一个动作。[要移动的动画是否等待, 命中时的动画是否等待]


  # 伤害...是否在目标到达时计算伤害。


  # 追踪...是否对移动的目标追踪。


  # 镜头...动画是否会随着镜头缩放而放大缩小。


  # 循环...移动动画结束时，是否回到动画开始。


  # 禁止翻转...禁止在任何情况下翻转动画。


  # 武器...填入武器的动作名。不需要的话填入""


 


  # 动作名             判别     ID    开始 末  开始调整   末调整  速度 类型  轨道    Z轴       等待        伤害    追踪   镜头   循环 禁止翻转  武器


  "箭发射WT"       => ["m_a",[ 0,-1], 0, 1, [ 0, 0], [ 0, 0], 10,  2, [-3,-3], true, [ true, true],  true,  true,  true, false, false,  "箭"],


  "箭发射"         => ["m_a",[ 0,-1], 0, 1, [ 0, 0], [ 0, 0], 10,  2, [-3,-3], true, [false,false],  true,  true,  true, false, false,  "箭"],


  "水枪发射"       => ["m_a",[69,69], 0, 1, [ 0, 0], [ 0, 0], 10,  0, [ 0, 0], true, [ true, true],  true,  true,  true,  true, false,  ""],


  "武器投掷开始"   => ["m_a",[ 0,-1], 0, 1, [ 4,-6], [ 0, 0], 10,  2, [-3,-3], true, [ true,false],  true,  true,  true, false, false,  "旋转"],


  "武器投掷返回"   => ["m_a",[ 0, 0], 1, 0, [ 0, 0], [ 4,-6], 10,  0, [ 3, 3], true, [ true,false], false,  true,  true, false, false,  "旋转"],


 


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


 # ● 战斗动画 显示数据库中的战斗动画


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


  # ID...动画ID。-1 为武器设定的动画，-2 为二刀流另一只手的武器动画


  #              -3 为技能设定的动画


  # 对象...[0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标]


  # 追踪...动画是否会追踪对象坐标的移动。


  # 等待...是否等待到动画结束。


  # 伤害...是否应用伤害计算


  # 镜头...是否随着镜头缩放而放大缩小。


  # 禁止翻转...禁止在任何情况下翻转动画。


  # 翻转...翻转动画。


  # Z轴...动画是否显示在角色前方。


 


  # 动作名（伤害系）        判别     ID 对象  追踪   等待   伤害    镜头 禁止翻转  翻转    Z轴


  "对象动画武器"      => ["anime",  -1,  1, false, false,  true,  true, false,  false,  true],


  "对象动画武器WT"    => ["anime",  -1,  1, false,  true,  true,  true, false,  false,  true],


  "对象动画武器LWT"   => ["anime",  -2,  1, false,  true,  true,  true, false,  false,  true],


  "对象动画"          => ["anime",  -3,  1, false, false,  true,  true, false,  false,  true],


  "对象动画WT"        => ["anime",  -3,  1, false,  true,  true,  true, false,  false,  true],


 


 


  # 动作名（自身系）          判别     ID 对象  追踪   等待   伤害    镜头 禁止翻转  翻转    Z轴


  "魔法吟唱中"          => ["anime", 113,  0,  true,  true, false,  true, false,  false,  true],


  "特技待机中"          => ["anime", 114,  0,  true,  true, false,  true, false,  false,  true],


  "魔法发动动画"        => ["anime", 115,  0, false,  true, false,  true, false,  false, false],


  "特技发动动画"        => ["anime", 116,  0, false,  true, false,  true, false,  false, false],


 


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


 # ● 镜头动作 执行画面的缩放和滚动


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


  # 对象...移动和缩放的对象


  #       [0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标] [6=画面]


  # 调整坐标...微调镜头坐标的最终地点 [X轴（正值为向右）, Y轴（正值为向下）]


  # 时间...镜头动作所需的时间


  # 缩放...镜头的缩放率（%）。100表示无缩放。


  # 等待...是否等待镜头动作结束。


 


  # 动作名            判别     对象   调整坐标   缩放  时间  等待


  "镜头复位"     => ["camera",   6, [   0,   0], 100,  40, false],


  "放大"         => ["camera",   6, [   0, 100], 120,  40, false],


  "缩小"         => ["camera",   6, [   0,   0],  80,  40, false],


 


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


 # ● 画面的震动 震动画面。空中坐标（H坐标在0以上）的战斗者不会震动。


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


  # 方向...震动的方向 [横, 纵]。数值越大，振幅越大。


  # 速度...震动的速度。数值越小，震动越快。


  # 时间...震动的持续时间。振幅会随着时间逐渐减小。


  # 等待...是否等待震动结束。


 


  # 动作名          判别       方向  速度   时间   等待


  "震动小"     => ["shake", [  0, 4],  2,    16, false],


  "震动中"     => ["shake", [  0, 6],  3,    30, false],


  "震动大"     => ["shake", [  0,12],  3,    40, false],


 


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


 # ● 更改画面色调 更改背景和战斗者的色调


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


  # 对象...更改色调的对象


  #       [0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标]


  #       [6=背景] [7=自身+目标] [8=自身以外] [9=自身+目标以外] [10=全体]


  # 色调等级...[ R, G, B, alpha（颜色的强度）, 更改时间, ※返回]


  #             ※返回....更改结束之后返回原色调所需时间。不反回的话填入 0


  # 等待...是否等待至画面色调更改结束


 


  # 更改名                        判别    对象     R,   G,   B, alpha 时间 返回  等待


  "色调初始化"               => ["color",  10, [   0,   0,   0,   0,  30,   0], false],


  "危机色调"                 => ["color",   0, [ 255,  50,  50, 100,  40,  40], false],


  "毒色调"                   => ["color",   0, [ 170,  50, 255, 170,  30,  30], false],


  "通用状态异常色调"         => ["color",   0, [ 255, 255,  50, 170,  40,  40], false],


  "背景变暗"                 => ["color",   6, [   0,   0,   0, 255,  30,   0], false],


  "除自己以外全变暗"         => ["color",   9, [   0,   0,   0, 255,  30,   0], false],


 


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


 # ● 渐变 画面固定后执行的渐变


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


  # 执行前请先执行动作"画面固定"固定住画面。


 


  # 边界...边界的模糊程度。数值越大越模糊。


  # 时间...渐变花费的事件。渐变过程中游戏的画面会固定住。


  # 渐变文件名...渐变用图像。请将图像放入 Pictures 文件夹。


 


  # 动作名              判别   边界  时间  渐变文件名


  "圆圈"         => ["ts",  40,   60,  "circle"],


 


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


 # ● 残影 战斗者的移动留下残影


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


  # 数...残影的个数。0 为消除正在显示的残影。数目过多会增加负荷。


  # 间隔...残影显示的间隔。数值越小，间隔越窄。单位为 1 帧。


  # 处理...残影的善后处理。true 表示全动作完成时消失，false表示开始终显示。


  # 透明度...残影的透明度。


 


  # 动作名              判别     数 间隔   处理  透明度


  "残像ON"        => ["mirage",  4,   3,  true,  160],


  "残像OFF"       => ["mirage",  0,   0,  true,    0],


 


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


 # ● 旋转战斗者 旋转战斗者的图像


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


  # 旋转的战斗者在全动作结束之后，旋转效果会被重置。


  # 旋转中的画像传送原点为画像中心。和翻转不同，不会体现在武器动作中。


  #


  # 时间...旋转耗费的事件。0 表示立刻旋转完成。


  # 开始度...开始旋转时的角度。指定 0～360° 。正为逆时针，负为顺时针。


  # 终度...旋转结束时的角度。指定 0～360° 。和上一条一样，敌人会按照相反方向计算。


  # 种类...旋转结束后的处理。[0...旋转重置] [1...保持结束时的角度] [2...训话]


 


  # 动作名  　          判别    时间  开始度  终度  种类


  "右1旋转"        => ["angle",  12,    0, -360,   0],


  "左1旋转"        => ["angle",  12,    0,  360,   0],


 


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


 # ● 缩放战斗者 缩放战斗者的图像


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


  # 缩放的战斗者在全动作结束之后，缩放效果会被重置。


  # 和翻转不同，不会体现在武器动作中。


  #


  # 时间...缩放所花费的时间。


  # 开始大小...缩放开始时的大小。请输入小数。[X轴（横向）, Y轴（纵向）]


  # 结束大小...缩放结束时的大小。请输入小数。[X轴（横向）, Y轴（纵向）]


  # 类型...缩放结束后的处理。[0...缩放重置] [1...保持结束时的大小] [2...循环]


 


  # 动作名  　          判别    时间  开始大小      结束大小  种类


  "横缩"           => ["zoom",  12,  [1.0, 1.0],  [0.5, 1.0],  0],


  "纵缩"           => ["zoom",  12,  [1.0, 1.0],  [1.0, 0.5],  0],


 


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


 # ● 战斗者透明度操作 更改战斗者图像的透明度


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


  # 更改过透明度的战斗者在全动作结束之后，透明度操作会被重置。


  #


  # 时间...更改透明度所耗费的时间。


  # 开始...开始更改时的透明度。0 为完全消失的状态，255 为完全不透明的状态


  # 结束...结束更改时的透明度。


  # 影...影子是否同样更改透明度。


  # 武器...武器是否同样更改透明度。


  # 循环...透明度更改结束后，操作是否自动回滚。


  # 等待...是否等到操作结束后再执行下一个动作。


 


  # 动作名 　              判别      时间  开始  结束   影    武器   循环   等待


  "逃走透明"         => ["opacity",   30,  255,   0,  true,  true, false, false],


  "透明化"           => ["opacity",   60,  255,   0,  true,  true, false, false],


  "透明化WT"         => ["opacity",   60,  255,   0,  true,  true, false,  true],


  "透明化解除"       => ["opacity",   60,    0, 255,  true,  true, false, false],


  "透明化解除WT"     => ["opacity",   60,    0, 255,  true,  true, false,  true],


 


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


 # ● fuki 动画 显示事件中弹出的图标


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


  # 种类...用 0～9 指定fuki的种类（纵位置）


  # 速度...更新速度。元件会从第二格开始播放。


  # 大小...fuki的大小


 


  # fuki 动画名　　       判别      种类 速度  大小


  "状态异常/通用"   => ["balloon",   6,  10,  0.6],


  "状态异常/危机" => ["balloon",   5,  10,  0.6],


  "状态异常/睡眠"   => ["balloon",   9,  10,  0.6],


 


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


 # ● 显示图片 用于大招显示立绘等


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


  # ID...使用的图片 ID。用于管理图片的 ID。不限制显示图片的数量。


  #      在全动作结束后会自动消除（释放 Bitmap）。


  # 开始坐标...移动开始的位置。以图片左上方为原点。[X轴, Y轴]


  #            如果已经存在图片，设为 [] 会以该位置作为开始坐标。


  # 结束坐标...移动结束的位置。若与开始位置相同，则图片只会显示不会移动。


  #            使用平面的场合，把开始和结束设为 [] 则保持移动速度。


  # 时间...移动时间。设为 0 表示消除图片。


  # Z轴...图片的Z坐标。设为 100 以上则显示在窗口前方。


  # 透明度...设定透明度。[开始时的透明度，每帧透明度的增加值]


  # 使用平面...使用平面类（图片平铺）时的矩形。[X轴, Y轴]


  #            不使用平面则设为 []


  # BA翻转...被偷袭时是否图像翻转、X坐标反向移动。


  #          使用平面时，设为 true 也不会翻转，仅仅会反向移动 X 坐标。


  # 图片文件名...Pictures 文件夹内的文件名。


 


  # 动作名              判别   ID    开始坐标     结束坐标    时间 Z轴   透明度    使用平面  偷袭翻转 图片文件名


  "插入A1"          => ["pic",  0, [-300,   8], [ 100,   8],  30, 90, [  0, 10],        [],  true, "Actor4-1"],


  "插入A2"          => ["pic",  0, [-300,   8], [ 100,   8],  30, 90, [  0, 10],        [],  true, "Actor4-2"],


  "插入A3"          => ["pic",  0, [-300,   8], [ 100,   8],  30, 90, [  0, 10],        [],  true, "Actor5-2"],


  "插入A4"          => ["pic",  0, [-300,   8], [ 100,   8],  30, 90, [  0, 10],        [],  true, "Actor5-3"],


  "插入終"          => ["pic",  0,          [], [ 600,   8],  30, 90, [255,  0],        [],  true, ""],


  "插入背景开始"    => ["pic",  1, [   0,   8], [ 100,   8],  10, 80, [  0, 10], [544,288],  true, "cutin_back"],


  "插入背景结束"    => ["pic",  1,          [],          [],  10, 80, [255, -7], [544,288],  true, ""],


  "白色背景淡入"    => ["pic",  0, [   0,   0], [   0,   0],  50,500, [  0,  6],        [], false, "white"],


  "白色背景淡出"    => ["pic",  0, [   0,   0], [   0,   0],  50,500, [255, -6],        [], false, "white"],


 


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


 # ● 状态操作


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


  # 对象...[0=自分] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标]


  # 扩展...在上述设定的基础上扩展 [0=无扩展] [1=随机一人] [2=自身除外]


  # 操作...附加状态为"+"，解除状态为"-"


  # 状态ID...将操作的状态ID全部填入数组。


 


  # 附加状态名           判别  对象 扩展 操作 状态ID


  "不能战斗"         => ["sta",  0,   0, "+",  [1]],


 


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


 # ● 更改FPS（游戏整体速度） 用于动作的细节检查


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


  # 游戏速度...默认为 60 ，数值越低，速度越慢。


 


  # 动作名               判别  游戏速度


  "游戏速度变慢"     => ["fps",  35],


  "游戏速度复原"     => ["fps",  60],


  "游戏速度变快"     => ["fps",  90],


 


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


 # ● 更改战斗者图像 将战斗者的图像更改为新的文件


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


  # 保持...己方角色是否在战斗后保持图像的更改。


  # 索引...己方角色使用行走图的哪个矩形。


  #        [0][1][2][3]


  #        [4][5][6][7]


  # 文件名...要更改至的图片文件名。角色的文件在 Characters 文件夹，


  #          敌人在 Battlers 文件夹。


  # 脸图...己方角色战斗后是否更改脸图。


  #        更改则填入[脸图索引, 文件名]，不更改则填入 []


 


  # 角色名                 判别     保持    索引      文件名       脸图


  "狼变身"            => ["change", false,    6,    "Animal", [0, "Actor4"]],


 


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


 # ● 技能派生 中断动作，派生引发新的技能


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


  # 习得...没有学会派生的技能时是否执行。


  # 代价条件...不足以支付派生技能的代价时是否执行。


  # 技能ID...派生技能的ID


 


  # 动作名               判别    习得  代价条件 技能ID


  "多段攻击"         => ["der",  true,  false,   130],


 


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


 # ● 播放声音  播放 BGM/BGS/SE


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


  # 类别...音效为"se"，BGM为"bgm"，BGS为"bgs"


  # 音调...音调。可以指定为 50～150 之间的数值。默认为 100。


  # 音量...音量。可以指定为 50～150 之间的数值。默认为 100。


  # 文件名...要播放的文件名。设为""表示修改其他设定但不更改 BGM、BGS。


 


  # 动作名             判别      类别  音调 音量  文件名


  "Bow1"          => ["sound",  "se", 100,  80, "Bow1"],


 


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


 # ● 播放影像  播放ogv格式的影像


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


  # 文件名...要播放的影像文件名。 影像在 Movies 文件夹。


 


  # 动作名                  判别     文件名


  "死亡视频" => ["movie", "sample1"],


 


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


 # ● 游戏开关（SideView专用开关）的操作


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


  # ID 为正表示操作游戏开关，为负表示操作 Sideview 专用开关


  #


  # ON...把要打开的开关 ID 全部填入数组


  # OFF...把要关闭的开关 ID 全部填入数组


  #


  # 动作名                判别      ON     OFF


  "开关No1/ON"      => ["switch",  [ 1],   []],


  "背景变为宇宙"    => ["switch",  [-4],   []],


  "背景变为宇宙解除"=> ["switch",    [],   [-4]],


  "魔法阵ON"        => ["switch",  [-5],   []],


  "魔法阵OFF"       => ["switch",    [],   [-5]],


 


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


 # ● 游戏变量的操作


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


  # ID...操作游戏变量的 ID


  # 操作...[0=赋值] [1=加法] [2=减法] [3=乘法] [4=除法] [5=剩余]


  # 运算数...用来进行计算的数值。设为负数的话，会以该数绝对值所对应的变量进行计算。


  #


  # 动作名　  　  判别               ID    操作  运算数


  "变量No1/+1"     => ["variable",   1,     1,     1],


 


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


 # ● 条件分歧（游戏开关） 设定条件，使动作发生分歧。


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


  # 开关ID...对应开关的 ID。负数则使用 SideView 专用开关。


  # 条件...打开为 true，关闭为 false


  # 分歧...满足条件时的分歧处理。不满足的情况则按照相反方式处理。


  #       [0=执行下一动作] [1=取消下一动作] [2=全动作结束]


  #


  # 动作名                   判别  开关ID  条件  分歧


  "开关No1=ON运行"       => ["n_1",   1,   true,   0],


 


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


 # ● 条件分歧 (游戏变量)


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


  # 变量ID...对应变量的 ID


  # 数值...填入作为条件的数值。设为负数的话，会以该数绝对值所对应的变量为准。


  # 条件...变量比条件数值...[0=相等] [1=小] [2=大]


  # 分歧...满足条件时的分歧处理。不满足的情况则按照相反方式处理。


  #       [0=执行下一动作] [1=取消下一动作] [2=全动作结束]


  #


  # 动作名                   判别  变量ID  数值  条件  分歧


  "变量No1=1运行"        => ["n_2",   1,    1,    0,    0],


 


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


 # ● 条件分歧 (状态)


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


  # 对象...检查条件的对象 [0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标]


  # 状态ID...使用几号状态作为条件。


  # 条件...[0=拥有状态] [1=没有状态]


  # 人数...满足以上条件所需人数。条件的对象为多人时，0 表示所有人。


  # 分歧...满足条件时的分歧处理。不满足的情况则按照相反方式处理。


  #       [0=执行下一动作] [1=取消下一动作] [2=全动作结束]


  #


  # 动作名                   判别   对象 状态ID 条件   人数  分歧


  "确认死亡"             => ["n_3",   1,    1,    0,     1,   1],


 


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


 # ● 条件分歧 (技能)


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


  # 对象...检查条件的对象 [0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标]


  # 技能ID...使用几号技能作为条件。


  # 条件...[0=可以使用] [1=不能使用]


  # 人数...满足以上条件所需人数。条件的对象为多人时，0 表示所有人。


  # 分歧...满足条件时的分歧处理。不满足的情况则按照相反方式处理。


  #       [0=执行下一动作] [1=取消下一动作] [2=全动作结束]


  #


  # 动作名                   判别  对象 技能ID  条件  人数  分歧


  "强击使用可限定"       => ["n_4",  0,   80,    0,    1,   0],


 


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


 # ● 条件分歧 (属性)


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


  # 对象...检查条件的对象 [0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标]


  # 类别...以哪一项属性作为条件。


  #       [1=Lv] [2=最大HP] [3=最大MP] [4=HP] [5=MP] [6=TP] [7=攻击力]


  #       [8=防御力] [9=魔法攻击] [10=魔法防御] [11=敏捷值] [12=幸运值]


  # 数值...填入作为条件的数值。设为负数的话，表示占对应属性最大值的百分比（仅限HP/MP/TP）


  # 条件...属性和条件数值相比...[0=相等] [1=小] [2=大]


  # 人数...满足以上条件所需人数。条件的对象为多人时，0 表示所有人。


  # 分歧...满足条件时的分歧处理。不满足的情况则按照相反方式处理。


  #       [0=执行下一动作] [1=取消下一动作] [2=全动作结束]


  #


  # 动作名                   判别  对象  类别  数值  条件  人数  分歧


  "HP50%以上运行"        => ["n_5",  0,    4,  -50,    2,    1,   0],


 


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


 # ● 条件分歧 (装备)


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


  # 对象...检查条件的对象 [0=自身] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标]


  # 种类...作为条件的装备种类 [0=武器] [1=防具]


  # 装备ID...对应种类的装备ID。将ID全部填入数组[]中。


  #          负数表示武器（防具）的种类、


  # 条件...[0=装备中] [1=未装备]


  # 人数...满足以上条件所需人数。条件的对象为多人时，0 表示所有人。


  # 分歧...满足条件时的分歧处理。不满足的情况则按照相反方式处理。


  #       [0=执行下一动作] [1=取消下一动作] [2=全动作结束]


  #


  # 动作名                  判别  对象   种类     ID    条件 人数  分歧


  "1号装备限定"          => ["n_6",  0,    0,    [1],    0,    1,   0],


  "拳限定"               => ["n_6",  0,    0,   [-2],    0,    1,   0],


  "拳除外"               => ["n_6",  0,    0,   [-2],    0,    1,   1],


  "弓限定"               => ["n_6",  0,    0,   [-6],    0,    1,   0],


  "弓除外"               => ["n_6",  0,    0,   [-6],    0,    1,   1],


  "拳弓除外"             => ["n_6",  0,    0,[-2,-6],    0,    1,   1],


 


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


 # ● 条件分歧 (脚本)　


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


  # 分歧...满足条件时的分歧处理。不满足的情况则按照相反方式处理。


  #       [0=执行下一动作] [1=取消下一动作] [2=全动作结束]


  # 脚本...填入返回值为 true 或 false 的脚本


  #


  # 动作名                判别   分歧   脚本


  "50%的概率运行"    => ["n_7",   0,  "rand(100) < 50"],


  "角色限定"         => ["n_7",   0,  "@battler.actor?"],


  "角色ID1限定"      => ["n_7",   0,  "@battler.actor? && @battler.actor_id == 1"],


  "角色ID2限定"      => ["n_7",   0,  "@battler.actor? && @battler.actor_id == 2"],


  "角色ID6限定"      => ["n_7",   0,  "@battler.actor? && @battler.actor_id == 6"],


  "角色ID7限定"      => ["n_7",   0,  "@battler.actor? && @battler.actor_id == 7"],


  "敌人限定"         => ["n_7",   0,  "[email protected]?"],


  "敌人中止"         => ["n_7",   2,  "[email protected]?"],


  "二刀流限定"       => ["n_7",   0,  "@battler.dual_wield?"],


 


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


 # ● 第二目标操作


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


  # 第二目标是指，与通常的目标相独立的另一目标的信息。


  # 没有操作时，第二目标会设为与通常目标相同。


  #


  # 对象...[0=自分] [1=目标] [2=敌方全体] [3=己方全体] [4=双方全体] [5=第二目标]


  #


  # INDEX...在队伍中的位置（队伍顺序）检索对象 INDEX = [索引, 判别]


  #         索引...队伍中索引值


  #         判别...数值条件 [0=不检索] [1=将该索引设为对象] [2=排除该索引]


  #


  # ID...通过角色（敌人）ID来检索对象。0 表示不检索。


  #      若为负值，则该数的绝对值将会作为排除条件。


  #


  # 状态...以对象当前拥有的状态 ID 作为检索条件。0 表示不检索。


  #        若为负值，则表示检索条件为对象不拥有该状态。


  #


  # 技能...以对象可以使用的技能 ID 作为检索条件。0 表示不检索。


  #        若为负值，则表示检索条件为对象不可使用该技能。


  #


  # 属性...以对象的属性为条件进行检索 属性 = [类别, 数值, 判别]


  #        类别...[1=Lv] [2=最大HP] [3=最大MP] [4=HP] [5=MP] [6=TP] [7=攻击力]


  #               [8=防御力] [9=魔法攻击] [10=魔法防御] [11=敏捷值] [12=幸运值]


  #        数值...填入作为条件的数值。设为负数的话，表示占对应属性最大值的百分比（仅限HP/MP/TP）


  #        判别...属性和条件数值相比...[0=相等] [1=小] [2=大]


  #


  # 装备...以对象的装备进行检索。仅限己方角色。装备 = [种类, ID]


  #       种类...[0=武器] [1=防具]


  #       ID...对应种类的装备ID。将ID全部填入数组[]中。


  #            负数表示武器（防具）的种类、


  #


  # 扩展...在上述设定的基础上扩展 [0=无扩展] [1=随机一人] [2=自身除外]


  # 操作...[0=无操作] [1=将通常目标变更为第二目标] [初开始化第二目标/通常目标]


 


  # 动作名               判别  对象  INDEX  ID  状态 技能   属性        装备   扩展 操作


  "自己以外己方全体"=> ["s_t", 3, [ 0, 0], 0,  0,   0, [ 0, 0, 0], [ 0,[0]],  2,   0],


  "全域化"           => ["s_t", 4, [ 0, 0], 0, -1,   0, [ 0, 0, 0], [ 0,[0]],  0,   1],


 


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


 # ● 呼叫公共事件


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


  # ID...公共事件ID


  # 等待...在公共事件执行时是否停止动作。


  #


  # 动作名                判别    ID    等待


  "公共事件No1"       => ["common",  1,  true],


 


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


 # ● 脚本操作


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


  # 执行脚本。把要用 eval 执行的脚本填入范例的 p = 1 处（p = 1 意思是弹出对话框 显示：1）。


  #


  # 脚本名


  "脚本" => ["p = 1 "],


 


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


 # ● 其他 无需设定项目即可加入全动作


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


  # 战斗动画消去...消除显示中的战斗动画（投掷动画不会消除）


  # 强制战斗结束...强制终止战斗。


  # 画面固定...固定游戏画面。在渐变前加入。


  # 伤害动画...播放技能动画，在动画即将结束时弹出伤害。


  # 反转...翻转图像和武器动画。再次翻转或全动作结束后解除翻转。


  # 武器消去...消除正在显示的武器图像。


  # 武器消去解除...显示已经消除的武器图像。


  # 敌死亡...执行消失效果。主要在敌方无法战斗时使用。


  # 死亡禁止...对象的HP为 0 时禁止死亡效果。可用于连续攻击开始之类的地方。


  # 死亡禁止解除...解除死亡禁止。可用于连续攻击结束之类的地方。即使不用这一条，行动结束时也会允许消失效果。


  # 待机无效...暂停待机动作。可用于战斗事件之类的地方。


  # 待机无效解除...解除待机无效，进行待机动作。


  # 初期位置变更...将原来的坐标（初开始位置）变更为现在的坐标。


  # 初期位置变更解除...恢复初期位置变更改变的坐标。


  # 强制...强制下次行动的目标（反作用）


  # 强制2...强制下次行动的第二目标（反作用）


  # 下一个行动者...视为战斗行动结束，立刻开始下一角色的行动。


  # 单个开始...单独处理多个目标的攻击时，重复行动开始的记号。


  # 单个结束...单独处理多个目标的攻击时，重复行动结束的记号。


  # 循环开始...不断重复"循环开始"与"循环结束"之间的行动。


  # 循环结束...不断重复"循环开始"与"循环结束"之间的行动。


 


  # 动作名                  判别


  "战斗动画消去"      => ["anime_off"],


  "强制战斗结束"      => ["battle_end"],


  "画面固定"          => ["graphics_freeze"],


  "伤害动画"          => ["damage_anime"],


  "反转"              => ["mirror"],


  "武器消去"          => ["weapon_off"],


  "武器消去解除"      => ["weapon_on"],


  "敌死亡"            => ["normal_collapse"],


  "死亡禁止"          => ["no_collapse"],


  "死亡禁止解除"      => ["collapse"],


  "待机无效"          => ["non_motion"],


  "待机无效解除"      => ["non_motion_cancel"],


  "初期位置变更"      => ["change_base_position"],


  "初期位置变更解除"  => ["set_base_position"],


  "强制"              => ["force_action"],


  "强制2"             => ["force_action2"],


  "下一个行动者"      => ["next_battler"],


  "单个开始"          => ["individual_start"],


  "单个结束"          => ["individual_end"],


  "循环开始"          => ["loop_start"],


  "循环结束"          => ["loop_end"],


 


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


 # ● 等待 到下个行动前的等待时间


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


  # 当动作名只有数字时，该数字即为等待的时间。


  #（例） "20"...等待 20 帧进入下一动作。


  #


  # 数值为负表示等待时间为 0～绝对值 之间的一个随机数。


  #（例） "-20"...随机等待 0～20 帧。


 


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


 # ● 快捷指令


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


  # 一般来说，把动作名写入全动作数组才可以完成行动的制作。


  # 其实也可以不设定动作，直接以描述指令，可以减少作业量。


  # 频繁使用快捷方式可以减少记录的动作数量，因此推荐使用。


  #


  # [战斗动画]


  # (例) "anime(20)" ... 在目标上执行数据库中 20 号的动画（有等待）


  # (例) "anime(20,false)" ...在目标上执行数据库中 20 号的动画（无等待）


  # (例) "anime_me(20)" ...自身执行数据库中 20 号的动画（有等待）


  # (例) "anime_me(20,false)" ...自身执行数据库中 20 号的动画（无等待）


  #


  # [等待 按索引延迟] ※ 根据角色在队伍中的索引，给等待加上延迟。


  # (例) "delay(12)"...1号队员等待 0 帧 2号队员等待12帧 3号队员等待24帧...


  #


  # [音效(SE)]


  # (例) "se('Bow1')" ...播放文件名名为Bow1的SE。


  # (例) "se('Bow1',50)" ...音量设为 50，播放文件名名为Bow1的SE。


  #


  # [强制目标动画（全动画）]


  # (例) "target('伤害的硬直')" ...强制目标执行"伤害的硬直"动作


  # (例) "target2('被伤害')" ...强制第二目标执行"被伤害"动作


 


  }


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


# ■ 全动作


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


#   将动作组合起来，从左到右顺次执行。


#   全动作中可以加入全动作，可以方便动作的元件化、条件分歧后放入全动作等方面。


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


  FULLACTION = {


 


  # 待机系


  "通常待机"        => ["待机"],


  "通常待机固定"    => ["待机固定WT"],


  "危机待机"        => ["状态异常/危机","危机色调","待机","待机"],


  "防御待机"        => ["待机固定WT"],


  "毒待机"          => ["状态异常/通用","毒色调","待机","待机","敌人限定","80"],


  "睡眠待机"        => ["状态异常/睡眠","敌人限定","40","敌人中止","死亡","死亡"],


  "通用状态异常待机"=> ["状态异常/通用","通用状态异常色调","待机","待机","敌人限定","80"],


  "观望"            => ["待机","60"],


  "无法战斗"        => ["死亡"],


 


  # 系统系


  "战斗开始己方"    => ["战斗前己方配置","delay(4)","坐标复位向左"],


  "己方退场"        => ["退场"],


  "逃走"            => ["对象动画","镜头复位","delay(4)","退场"],


  "敌逃走"          => ["对象动画","逃走透明","退场"],


  "逃走失敗"        => ["镜头复位","delay(4)","逃走途中","一步后移动","坐标复位向左"],


  "命令输入"        => ["战斗动画消去","命令输入移动"],


  "命令输入结束"    => ["坐标复位早"],


  "命令后防御"      => ["待机固定WT"],


  "命令后魔法"      => ["待机固定","魔法吟唱中"],


  "命令后特技"      => ["待机固定","特技待机中"],


  "防御"            => ["对象动画","待机固定WT"],


  "回避"            => ["角色限定","右1旋转","一步后跳跃","10","坐标复位向左"],


  "盾格挡"          => ["se('Evasion2')","盾防御","60"],


  "替身开始"        => ["敌中移动早","初期位置变更"],


  "替身结束"        => ["初期位置变更解除","坐标复位向左"],


  "被替身开始"      => ["一步后移动","一步后移动","待机固定WT"],


  "被替身结束"      => ["坐标复位向左"],


  "胜利姿态挥动"    => ["战斗动画消去","胜利跳跃武器","胜利跳跃着地","120"],


  "胜利姿态后空翻"  => ["战斗动画消去","右1旋转","胜利跳跃","拳限定","武器出拳","拳除外","武器挥动R","120"],


  "闪光"            => ["anime_me(119)","20"],


 


  # 反作用系


  "被伤害"          => ["伤害的硬直","坐标复位向左"],


  "被伤害大"        => ["震动中","伤害的硬直大","坐标复位向左"],


  "纵晃动"          => ["纵晃动01","纵晃动02","纵晃动01","纵晃动02","纵晃动01","纵晃动02"],


 


  # 快捷方式系（给其它全动作中调用）


  "斩"              => ["武器挥动R","对象动画武器","10"],


  "拳"              => ["武器出拳","对象动画武器","10"],


  "弓"              => ["Bow1","弓射击","箭发射","9"],


  "攻击"            => ["拳限定","拳","弓限定","弓","拳弓除外","斩"],


  "通常攻击开始"    => ["敌前移动","死亡禁止","单个开始","二刀流限定","二刀左"],


  "通常攻击结束"    => ["确认死亡","对象动画武器WT","单个结束","死亡禁止解除","下一个行动者","坐标复位曲线"],


  "二刀左"          => ["武器挥动L","对象动画武器LWT"],


  "特技发动"        => ["一步向前移动","武器拿出","特技发动动画"],


  "魔法发动"        => ["一步向前移动","武器拿出","魔法发动动画"],


  "插入"            => ["插入背景开始","插入分歧","70","插入終","插入背景结束","20"],


  "插入分歧"        => ["角色ID1限定","插入A1","角色ID2限定","插入A2","角色ID6限定","插入A3","角色ID7限定","插入A4"],


  "死亡フラグ動画"  => ["白色背景淡入","50","死亡视频","白色背景淡出","50"],


  "背景宇宙"        => ["缩小","se('Blind',70)","背景变暗","自己以外己方全体","强制2","透明化","透明化","40","背景变为宇宙","色调初始化"],


  "背景宇宙解除"    => ["镜头复位","背景变暗","target2('透明化解除WT')","透明化解除","40","背景变为宇宙解除","色调初始化"],


  "魔法阵表示"      => ["se('Blind',70)","画面固定","魔法阵ON","圆圈"],


  "魔法阵消去"      => ["40","画面固定","魔法阵OFF","圆圈"],


 


  # 普通攻击系


  "通常攻击"        => ["通常攻击开始","待机固定","通常攻击结束"],


  "斩攻击"          => ["通常攻击开始","确认死亡","武器挥动R","通常攻击结束"],


  "拳攻击"          => ["通常攻击开始","武器出拳","通常攻击结束"],


  "刺攻击"          => ["通常攻击开始","武器刺","通常攻击结束"],


  "弓攻击"          => ["一步向前移动","死亡禁止","单个开始","Bow1","弓射击",


                        "箭发射WT","单个结束","死亡禁止解除","坐标复位"],


 


  # 技能系


  "通用特技"        => ["特技发动","武器挥动R","伤害动画","坐标复位"],


  "通用魔法"        => ["魔法发动","武器挥动R","伤害动画","坐标复位"],


 


  "水枪"            => ["特技发动","武器挥动R","水枪发射","坐标复位"],


  "武器投掷"        => ["特技发动","Bow1","武器挥动R","6","待机固定","武器投掷开始","武器投掷返回","坐标复位"],


  "插入图片攻击"        => ["特技发动","插入","攻击","坐标复位"],


  "影像攻击"        => ["特技发动","待机固定","死亡フラグ動画","通常攻击开始","武器挥动R","通常攻击结束"],


  "狼人变身"        => ["特技发动","anime(110,false)","狼变身","待机固定","120","坐标复位"],


  "5回攻击"         => ["特技发动","死亡禁止","弓除外","敌前移动","攻击","攻击","攻击","攻击","攻击","死亡禁止解除","坐标复位"],


  "特技派生"        => ["武器投掷","多段攻击","斩攻击"],


  "背景变更攻击"    => ["魔法发动","武器挥动R","背景宇宙","伤害动画","背景宇宙解除","坐标复位"],


  "图片攻击"        => ["魔法发动","魔法阵表示","武器挥动R","anime(80,false)","60","震动大","对象动画","魔法阵消去","坐标复位"],


  "变暗攻击"        => ["特技发动","除自己以外全变暗","se('Laser',150)",


                        "残像ON","敌前移动","anime(35,false)","敌后移动","对象动画",


                        "武器挥动R","20","色调初始化","坐标复位","残像OFF"],


  "空中攻击"        => ["特技发动","Bow1","一步前跳跃","杖打击前跳跃",


                        "待机固定","左1旋转","10","anime(117,false)","杖打击",


                        "对象动画","震动中","强制","纵晃动","20",


                        "一步后跳跃","坐标复位"],


 


  # 道具系


  "使用物品"     => ["敌前移动","待机固定","对象动画WT","坐标复位向左"],


 


 


 


  }


 


 


 


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


# ■ 战斗程序


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


#   对战斗场景的演出进行时间管理


#   通过游戏开关、SideView专用开关进行控制


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


  BATTLE_PROGRAM = {


 


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


 # ● 开关控制  通过开关的时间操作来控制演出


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


  # 开关...作为执行程序的信号的游戏开关ID。设为负数则使用 SideView 专用开关。


  #        开关关闭后，执行中的程序将会终止。


  #        SideView 专用开关在战斗结束后会初开始化（全部关闭）


  #        若要在事件中操作 SideView 专用开关，


  #        请执行事件脚本 $sv_camera.switches[1] = true


  #        (1 为操作的开关 ID，打开则设为 true，关闭则设为 false)


  #


  # ON...打开的开关ID。设为负数则使用 SideView 专用开关。


  #      将 ID 全部填入数组中。


  #      例...[1,2,-5] 打开游戏开关 1、2 以及 SideView 专用开关 5


  #


  # OFF...关闭的开关ID。设为负数则使用 SideView 专用开关。


  #       不需要操作时填入 []


  #


  # 时间...执行上述开关操作所需要的时间（单位为帧）


  #        若设为 100，从程序开始 100 帧后执行开关操作


  #        [参考值] 30秒...1800　1分钟...3600　5分钟...18000 10分钟...36000　1小时...216000


  #


  # 随机范围...加进时间的随机值的范围，单位为帧


  #            比如时间300，随机范围300的话，最终的时间将会是 300～600 帧。


 


  # 名称                判别     开关    ON       OFF   时間  随机范围


  "背景变堡垒"       => ["switch",  -1,   [-2],      [],  1200,     0],


  "背景变海"         => ["switch",  -2,   [-3],      [],  2400,     0],


 


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


 # ● 播放 SE/BGM/BGS


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


  #


  # 开关...作为执行程序的信号的游戏开关ID。设为负数则使用 SideView 专用开关。


  #


  # 类别...音效为"se"，BGM为"bgm"，BGS为"bgs"


  # 音调...音调。可以指定为 50～150 之间的数值。默认为 100。


  # 音量...音量。可以指定为 50～150 之间的数值。默认为 100。


  # 文件名...要播放的文件名。设为""表示修改其他设定但不更改 BGM、BGS。


 


  # 名称                 判别   开关  类别   音调  音量 文件名


  "海浪声"            => ["sound",  -1, "bgs",  100,  80, "Sea"],


 


 #--------------------------------------------------------------------------、


 # ● 背景的控制 执行更改图片、自动滚动


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


  # 开关...作为执行程序的信号的游戏开关ID。


  # No....所操作的背景的序号。1为地板背景，2为墙壁背景（远景）


  #


  # 滚动速度...背景移动的速度。[X轴, Y轴]


  #            单位为每 100 帧移动的像素数。


  #            要高速移动，请使用 1000 的数量级。


  #


  # BA翻转...被偷袭时背景的X坐标滚动是否反向。图像不会翻转。


  #


  # 图像...如果想要更改背景图，就填入文件名，否则填入 ""


  #        地板背景在 Battlebacks1 文件夹，墙壁背景在 Battlebacks2 文件夹。


  #        更改后的背景设定会继承更改前的设定。


  #


  # 中间图...为了使滚动背景时，背景的更改变得更加自然，所需要的中间图的文件名。


  #          如果滚动过程中背景发生了更改，会在滚动结束后再更改。


  #


  # 插入...显示此背景时是否允许其他背景控制的插入。


  #        允许则填 true（中间图显示时，只有没有滚动的背景可以插入）


  #        不允许则填 false（保留其他的背景控制，直到该背景结束时再进行更改）


 


  # 名称                判别   开关  No.   滚动速度    BA翻转   图像        中间图        插入


  "远景向右移动"  => ["scroll", -1,  1, [  40,    0],  true,  "",                 "",  true],


  "海背景3变更"   => ["scroll", -2,  1, [ 120,    0],  true,  "Sea_ex03", "Sea_ex02",  true],


  "海背景4变更"   => ["scroll", -3,  1, [  40,    0],  true,  "Sea_ex01", "Sea_ex04",  true],


  "宇宙变更1"     => ["scroll", -4,  1, [   0,    0],  true,  "DarkSpace",        "", false],


  "宇宙变更2"     => ["scroll", -4,  2, [   0,    0],  true,  "DarkSpace",        "", false],


 


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


 # ● 周期图像 周期性地操作瓷砖状的图片。比如风和巨大魔法阵。


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


  # 开关...作为执行程序的信号的游戏开关ID。


  # No....操作的图片编号。显示图片的数量没有限制。


  # 移动速度...每 100 帧图片移动的速度。[X轴, Y轴]。0 表示与背景滚动同步。


  # 时限...该程序执行的时限。单位为帧。设为 0 表示不断循环。


  #


  # 透明操作...图片的透明度操作。[开始透明度, 每 100 帧增加的透明度]


  #            透明度达到 255 时会回到开始的透明度，再重复这样的过程。


  # Z轴...图片的 Z 坐标。设为 100 以上则显示在窗口前方。


  # 允许震动...是否允许与震动动作的震动联动。


  # BA翻转...被偷袭时图片的X坐标滚动是否反向。图像不会翻转。


  # 文件名...图片的文件名。文件在 Pictures 文件夹里。


 


  # 名称             判别   开关  No.   移动速度     时限    透明操作   Z轴    允许震动 BA翻转 文件名


  "风"            => ["kpic", -1,  0, [  500,    0],    0, [ 255,   0],  90,   false,  true, "back_wind"],


  "魔法阵"        => ["kpic", -5,  1, [    0,    0],    0, [ 255,   0],  90,    true,  true, "magic_square01"],


 


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


 # ● 周期 SE  周期性地响起音效。比如雷鸣、波涛的声音。


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


  # 开关...作为执行程序的信号的游戏开关ID。


  # 周期...响起音效的周期。单位为帧。以此为间隔，音效会定期响起。


  # 随机范围...加在周期里的随机范围。单位为帧。


  #


  # 音调...音调。可以指定为 50～150 之间的数值。默认为 100。


  # 音量...音量。可以指定为 50～150 之间的数值。默认为 100。


  # 开始执行...程序执行之后，是否不等待一个周期直接响起音效。


  # 文件名...播放的文件名。


 


  # 名称               判别     开关 周期  随机范围 音调 音量 开始执行   文件名


  "海鸥"         => ["keep_se", -1,  400,    100,  150,  60,  false,  "Crow"],


  "海鸥2"        => ["keep_se", -1,  300,    200,  140,  45,   true,  "Crow"],


 


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


 # ● 周期震动  周期性地震动画面


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


  # 开关...作为执行程序的信号的游戏开关ID。开关打开时效果开始。


  # 周期...画面震动的周期。单位为帧。


  # 随机范围...加在周期里的随机范围。单位为帧。


  #


  # 方向...震动的方向 [横, 纵]。数值越大，振幅越大。


  # 速度...震动的速度。数值越小，震动越快。


  # 时间...震动的持续时间。震幅会随着时间逐渐减小、


  # 开始执行...程序执行之后，是否不等待一个周期直接开始震动。


 


  # 程序名                判别    开关 周期 随机范围   方向  速度  时间 开始执行


  "船的晃动"       => ["keep_sk", -1,  130,    0,  [  0, 4], 80,  120,  true],


 


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


 # ● 周期更改色调  周期性地更改画面的色调


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


  # 开关...作为执行程序的信号的游戏开关ID。开关打开时效果开始。


  # 周期...更改色调的周期。单位为帧。


  # 随机范围...加在周期里的随机范围。单位为帧


  #


  # 对象...更改色调的对象 [0=背景] [1=敌方全体] [2=己方全体] [3=双方全体] [4=全部]


  # 色调...[ R, G, B, alpha（颜色强度）, 更改时间, ※返回]


  #        ※返回...更改完成后回到原来的颜色所需要的时间。不还原的话填入 0。


  # 开始执行...程序执行之后，是否不等待一个周期直接更改色调。


 


  # 程序名       判别   开关   周期 随机范围 对象    R,   G,   B,  alpha 时间 返回  开始执行


  "雷光"     => ["keep_c",  0,  300,  100,     4,  [ 255, 255, 255, 255,   8,   8],  true],


  "紧急情况" => ["keep_c",  0,  150,    0,     4,  [ 255,   0,   0, 100,  40,  40],  true],


 


}


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


# ■ 镜头设定


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


#   除了动作外，其他战斗场景的各个点上均有镜头。


#   由于动作名会移动镜头，请不要改变名字。


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


  BATTLE_CAMERA = {


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


 # ● 镜头镜头  进行画面的缩放、滚动


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


  # 对象...移动、缩放的对象 [2=敌方全体] [3=己方全体] [4=双方全体] [6=画面]


  # 调整坐标...微调镜头坐标的最终地点 [X轴（正数为右）, Y轴（正数为下）]


  # 时间...镜头动作所需时间


  # 缩放...镜头的缩放率(%)。100 表示无缩放。


 


  # 动作名              判别     对象   调整坐标   缩放 时间


  "转身开始前"   => ["camera",   6, [  40,   0],  95, 40],


  "转身开始后"   => ["camera",   6, [   0,   0], 100, 40],


  "战斗结束时"     => ["camera",   6, [ 100,   0], 100, 50],


 


 


}


end

文雅夕露

1. num.x = (@num_base[index][0] - $sv_camera.x) * $sv_camera.zoom
   
2.     num.y = (@num_base[index][1] - $sv_camera.y) * $sv_camera.zoom
   
3.     num.opacity = 256 - (12 - @time) * 32
   
4.     num.visible = false if @time == 0

复制代码

大致在这里，看情况改吧。