Project1

标题: Sideview横版战斗的问题 [打印本页]

作者: wuyueyu 时间: 2012-12-3 20:02
标题: Sideview横版战斗的问题

战斗测试时画面花的...
#==============================================================================
# ■ Sideview
#------------------------------------------------------------------------------
# 　サイドビューバトラーを管理するクラスです。
#==============================================================================
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 :derivation_skill_id  # スキル派生ID
  attr_accessor :immortal          # 不死身フラグ
  attr_accessor :mirage             # 残像データ
  attr_accessor :balloon_data       # ふきだしデータ
  attr_accessor :timing             # 別バトラーからのタイミングデータ
  attr_accessor :color_set          # 色調変更データ
  attr_accessor :color             # 色調データ
  attr_accessor :change_up          # 画像変更フラグ
  attr_accessor :hit                # 被攻撃回数
  attr_accessor :add_state          # 何度も付加ステートの表示を防ぐフラグ

  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
@derivation_skill_id = 0
@immortal = false
@mirage = []
@play_data = []
@balloon_data = []
@picture = false
@timing = []
@color_set = []
@color = []
@change_up = false
@non_motion = false
@graphics_change = false
@hit = 0
@add_state = []
@collapse = 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
  end
  #--------------------------------------------------------------------------
  # ● セットアップ
  #--------------------------------------------------------------------------
  def setup(bitmap_width, bitmap_height, first_action_flug)
reset
set_data
set_base_position if !@graphics_change
set_graphics(bitmap_width, bitmap_height)
set_target
setup_graphics_change if @graphics_change
start_action(first_action) if first_action_flug && @battler.movable?
stand_by_action if first_action_flug && [email protected]?
  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 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
  #--------------------------------------------------------------------------
  # ● グラフィックデータ取得
  #--------------------------------------------------------------------------
  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
  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_target(target = nil)
@target_battler = target
@target_battler = [@battler] if target == nil
@second_targets = @target_battler.dup
  end
  #--------------------------------------------------------------------------
  # ● アクション開始
  #--------------------------------------------------------------------------
  def start_action(kind = nil)
# ウェイト中の場合キャンセル
return @wait -= 1 if @wait > 0 && kind == nil
action_setup 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
@set_damage = false
@action_end = false
@balloon_data = []
@loop_act = []
angle_reset
zoom_reset
opacity_reset
@curve = []
@c = 0
convert_jump
  end
  #--------------------------------------------------------------------------
  # ● 行動終了処理
  #--------------------------------------------------------------------------
  def action_terminate
@mirage = [] if @mirage_end
mirroring_reset
@picture = false
# 待機アクションへ移行
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
# ショートカット確認
eval(@action) if @action != nil && @action_data == nil && N03::FULLACTION[@action] == nil
# ウエイト設定
@wait = 0
@wait = @action.to_i if @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
set_action(stand_by_act)
@action = stand_by_act if @action == nil
  end
  #--------------------------------------------------------------------------
  # ● 強制アクション開始
  #--------------------------------------------------------------------------
  def start_force_action
# ウエイト・モーション系以外の現在のアクションを保持
#remain_act = @action if @action_data != nil && @action_data[0] != "motion"
@full_action= []
start_action(@force_action)
# フルアクションの最後に現在のアクションを挿入
#@full_action.push(remain_act) if remain_act != nil
@force_action = ""
  end
  #--------------------------------------------------------------------------
  # ● 複数のアクションを繋げて開始
  #--------------------------------------------------------------------------
  def start_plural_action(kinds)
full_act = []
for kind in kinds
   act = N03::FULLACTION[kind]
   act = [kind] if act == nil
   full_act += act
end
@full_action = full_act.dup
@action = @full_action.shift
full_act = N03::FULLACTION[@action]
@full_action = full_act.dup + @full_action if full_act != nil
@action_data = N03::ACTION[@action]
next_action
  end
  #--------------------------------------------------------------------------
  # ● アクション追加
  #--------------------------------------------------------------------------
  def add_action(kind)
@full_action.push(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 @pattern_w == 0 && @pattern_h == 0
@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 + @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 opacity_reset 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 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 @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 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 [email protected]? && 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]
  end
  #--------------------------------------------------------------------------
  # ● 透明度操作初期化
  #--------------------------------------------------------------------------
  def opacity_reset
@opacity = 255
@opacity_data = []
  end
  #--------------------------------------------------------------------------
  # ● バトラーアニメ実行
  #--------------------------------------------------------------------------
  def battler_anime(anime_data = nil)
anime_data = @action_data.dup if anime_data == nil
@graphic_file_index = anime_data[1]
@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.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
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]
targets = N03.get_targets(data[2], @battler)
@wait = N03.get_anime_time(@damage_anime_data[0]) - 2 if data[4]
return if @set_damage
for target in targets do display_anime(target, data) end
  end
  #--------------------------------------------------------------------------
  # ● 武器アニメ開始
  #--------------------------------------------------------------------------
  def weapon_anime(anime_data)
@weapon_end = true
for i in 9...anime_data.size
   set_effect_data(anime_data) if anime_data != ""
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)
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_flug = true
for starter in starters
   for target in targets
      data = @action_data.dup
      data[17] = se_flug
      @effect_data.push(data)
      @m_a_targets.push(target)
      @m_a_starter.push(starter)
      se_flug = false
   end
end
  end
  #--------------------------------------------------------------------------
  # ● スプライトセット通信
  #--------------------------------------------------------------------------
  def set_effect_data(data = @action)
action_data = N03::ACTION[data]
return if action_data == nil
#msgbox(action_data)
@effect_data.push(action_data.dup)
  end
  #--------------------------------------------------------------------------
  # ● 戦闘シーン通信のデータを格納
  #--------------------------------------------------------------------------
  def set_play_data(data = @action_data)
@play_data = data.dup
  end
  #--------------------------------------------------------------------------
  # ● 戦闘アニメの表示
  #--------------------------------------------------------------------------
  def display_anime(battler, data)
battler.animation_id       = data[1]
battler.animation_mirror    = data[8]
battler.sv.anime_horming    = data[3]
battler.sv.anime_camera_zoom = data[6]
battler.sv.anime_no_mirror = data[7]
  end
  #--------------------------------------------------------------------------
  # ● 戦闘アニメ拡張データの初期化
  #--------------------------------------------------------------------------
  def reset_anime_data
@anime_no_mirror = false
@anime_horming = false
@anime_camera_zoom = false
  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
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 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)
case @action_data[2]
when 1 ; targets = [targets[rand(targets.size)]]
when 2 ; targets -= @battler if targets.include?(@battler)
end
for target in targets
   target.add_state(@action_data[4]) if @action_data[3] == "+"
   target.remove_state(@action_data[4]) if @action_data[3] == "-"
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 [email protected]?
@pre_change_data = [@battler.character_name, @battler.character_index, @battler.face_name, @battler.face_index] if @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] && [email protected]_learn?($data_skills[@action_data[3]])
# コスト不足は派生不可なら
return if !@action_data[2] && [email protected]_cost_payable?($data_skills[@action_data[3]])
# 派生
@derivation_skill_id = @action_data[3]
  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
$game_switches[@action_data[1]] = @action_data[2]
$sv_camera.program_check
  end
  #--------------------------------------------------------------------------
  # ● ゲーム変数操作
  #--------------------------------------------------------------------------
  def variable
# オペランドチェック
operand = @active_action[3]
operand = $game_variables[@active_action[3].abs] if @active_action[3] < 0
# 変数操作で分岐
case @active_action[2]
when 0 ; $game_variables[@active_action[1]] = operand  # 代入
when 1 ; $game_variables[@active_action[1]] += operand # 加算
when 2 ; $game_variables[@active_action[1]] -= operand # 減算
when 3 ; $game_variables[@active_action[1]] *= operand # 乗算
when 4 ; $game_variables[@active_action[1]] /= operand # 除算
when 5 ; $game_variables[@active_action[1]] %= operand # 剰余
end
  end
  #--------------------------------------------------------------------------
  # ● 条件分岐 (ゲームスイッチ)
  #--------------------------------------------------------------------------
  def nece_1
judgment = $game_switches[@action_data[1]] == @action_data[2]
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)
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)
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)
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)
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] > 0 && !target.comparison_equip(@action_data[7])
   targets.delete(target) if @action_data[7][1] < 0 && target.comparison_equip(@action_data[7])
end
case @action_data[8]
when 1 ; targets = [targets[rand(targets.size)]]
when 2 ; targets.delete(@battler)
end
@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 normal_collapse
@collapse = true
return
  end
  #--------------------------------------------------------------------------
  # ● 初期位置変更
  #--------------------------------------------------------------------------
  def change_base_position
@base_x = @x
@base_y = @y
@base_h = @h
  end
  #--------------------------------------------------------------------------
  # ● 強制アクション実行
  #--------------------------------------------------------------------------
  def force_act
act = @full_action.shift
for target in @target_battler do target.sv.force_action = act end
  end
  #--------------------------------------------------------------------------
  # ● 強制アクション実行 (セカンドターゲット)
  #--------------------------------------------------------------------------
  def force_act2
act = @full_action.shift
for target in @second_targets do target.sv.force_action = act end
  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
  end
  #--------------------------------------------------------------------------
  # ● 画像変更フラグ
  #--------------------------------------------------------------------------
  def set_change
@change_up = true
  end
  #--------------------------------------------------------------------------
  # ● 戦闘シーン通信
  #--------------------------------------------------------------------------
  def play_data
data = @play_data
@play_data = []
return data
  end
  #--------------------------------------------------------------------------
  # ● 戦闘アニメを表示するX座標
  #--------------------------------------------------------------------------
  def anime_x(position = 0)
return @x
  end
  #--------------------------------------------------------------------------
  # ● 戦闘アニメを表示するY座標 position = (0:頭上、1:中心、2:足元、3:画面)
  #--------------------------------------------------------------------------
  def anime_y(position = 1)
return @y
case position
when 0 ; return @y - @ch * 100
when 1 ; return @y - @ch * 50
when 2 ; return @y
when 3 ; return @y
end
  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
  #--------------------------------------------------------------------------
  # ● バトラーのIDを取得
  #--------------------------------------------------------------------------
  def id
return @battler.id if @battler.actor?
return [email protected]
  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 [email protected][0]
return @battler.weapons[0].id
  end
  #--------------------------------------------------------------------------
  # ● 装備武器のタイプを取得
  #--------------------------------------------------------------------------
  def weapon_type
return 0 if [email protected][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
  #--------------------------------------------------------------------------
  # ● スキルIDを取得
  #--------------------------------------------------------------------------
  def skill_id
return 0 if @battler.current_action == nil or @battler.current_action.item == nil
return @battler.current_action.item.id
  end
  #--------------------------------------------------------------------------
  # ● スキルのタイプを取得
  #--------------------------------------------------------------------------
  def skill_type
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.stype_id
  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)
start_action(act) if act != nil
  end
  #--------------------------------------------------------------------------
  # ● 回避アクション
  #--------------------------------------------------------------------------
  def evasion_action(attacker, item)
damage_action_base(item)
act = evasion(attacker)
start_action(act) if act != nil
  end
  #--------------------------------------------------------------------------
  # ● ミスアクション
  #--------------------------------------------------------------------------
  def miss_action(attacker, item)
damage_action_base(item)
act = miss(attacker)
start_action(act) if act != nil
  end


end

#==============================================================================
# ■ module N03
#------------------------------------------------------------------------------
# 　サイドビューバトルでよく使う処理です。
#==============================================================================
module N03
  #--------------------------------------------------------------------------
  # ● 戦闘アニメ時間の取得
  #--------------------------------------------------------------------------
  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 0 if battler.current_action == nil
case kind
when -1 ; anime_id = battler.atk_animation_id1
when -2 ; anime_id = battler.atk_animation_id2
when -3 ; anime_id = battler.current_action.item.animation_id
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
  end
  #--------------------------------------------------------------------------
  # ● ターゲットの取得
  #--------------------------------------------------------------------------
  def self.get_targets(kind, battler)
case kind.abs
when 0 ; return [battler]
when 1 ; return battler.sv.target_battler
when 2 ; return $game_troop.members
when 3 ; return $game_party.battle_members
when 4 ; return $game_troop.members + $game_party.battle_members
when 5 ; return battler.sv.second_targets
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.sv.base_x if !horming
   y += targets.sv.base_y if !horming
   h += targets.sv.base_h if !horming
   x += targets.sv.x if horming
   y += targets.sv.y if horming
   h += targets.sv.h if horming
   y -= targets.sv.ch * 100 if m_a == 0
   y -= targets.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 = move_data[0]
   move_d = 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
position = self.get_targets_position(targets, true)
sv_camera.move(position[0], position[1] + position[2], data[3], data[4], 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 :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])
   @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)
   @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 = 100000
@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_flug = @move_data[17]
# 開始位置を取得
start_position
@z_plus = 100000 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_flug = false
@auto_through_flug = 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 = orbit_data[0]
   orbit_data[0] /= 2
   orbit_d = 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
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
self.y += $sv_camera.sy / 100
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
time = move_calculation(moving_x, moving_y, goal_x, goal_y)
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_flug, []])
@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_flug = true
se_flug = @se_flug if @se_flug != nil
for target in @timing_targets
   target.sv.timing.push([se_flug, timing.dup])
   se_flug = 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 [email protected] or @data[9] != ""
return @action_end = true if [email protected]
@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 [email protected]
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
  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_base = []
   @st = Sprite.new
   bitmap_state(@st, states)
   @st_base[0] = @direction * (-20 + 5 * i) + @battler.sv.x / 100
   @st_base[1] = -40 - @state_height * i + (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.oy_adjust)/ 100
   @st.z = 1000 + i
   @st.opacity = 0
end
@time = @pop_time = 80
  end
  #--------------------------------------------------------------------------
  # ● ステート画像
  #--------------------------------------------------------------------------
  def bitmap_state(state, state_object)
name = state_object.name
if FileTest.exist?("Graphics/System/" + name+ ".png") or FileTest.exist?("Graphics/System/" + name+ ".jpg")
   state.bitmap = Cache.system(name)
   @state_height = state.bitmap.height
else
   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
  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.mp_damage if @battler.result.mp_damage != 0
damage = @battler.result.tp_damage if @battler.result.tp_damage != 0
if !damage or damage == 0
   @action_end = true if @states == nil
   return
end
@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 = Sprite.new
   if add_file != nil && i == max_num - 1
      @num.bitmap = Cache.system(add_file)
      cw = (damage % (10 * 10 ** i))/(10 ** i)
      sw = 0 if sw == nil
   else
      @num.bitmap = Cache.system(file)
      cw = (damage % (10 * 10 ** i))/(10 ** i)
      sw = @num.bitmap.width / 10
      @num.src_rect.set(cw * sw, 0, sw, @num.bitmap.height)
   end
   @num_base = []
   @num_base[0] = (sw + adjust_x) * i * -1 + (@battler.sv.x / 100)
   @num_base[1] =  -(@num.bitmap.height / 3) - i * 2 - @hit * 2 + (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.oy_adjust)/ 100
   @num_base[0] -= @num.bitmap.width / 2 - adjust_x if add_file != nil && i == max_num - 1
   @num.z = 1000 + i + @hit * 10
end
@time = @pop_time = 80
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
return if @time == 0
for i in [email protected] do update_state_move(@st, i) end if @st != nil
for i in [email protected] do update_num_move(@num, 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 = 0
bitmap.dispose if bitmap
for i in [email protected] do @num.dispose end if @num != nil
for i in [email protected] do @st.dispose end if @st != nil
super
  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 damager in $sv_camera.damager do set_damage end if $sv_camera.damager != []
for i in [email protected]
   next if @damage == nil
   @damage.update if @damage != nil
   next if !@damage.action_end
   @damage.dispose
   @damage = nil
end
  end
  #--------------------------------------------------------------------------
  # ● ピクチャアクションの更新
  #--------------------------------------------------------------------------
  def update_pictures
for i in [email protected]
   next if @pictures == nil
   @pictures.update if @pictures != nil
   next if !@pictures.action_end
   @pictures.dispose
   @pictures = 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 == nil
   @back_pic.update if @back_pic != nil
   next if !@back_pic.action_end
   @back_pic.dispose
   @back_pic = nil
end
  end
  #--------------------------------------------------------------------------
  # ● 武器アクションの更新
  #--------------------------------------------------------------------------
  def update_weapons
for i in [email protected]
   next if @weapons == nil
   @weapons.update if @weapons != nil
   next if !@weapons.action_end
   @weapons.dispose
   @weapons = nil
end
  end
  #--------------------------------------------------------------------------
  # ● ダメージ実行
  #--------------------------------------------------------------------------
  def set_damage
for i in [email protected]
   next if @damage != nil
   return @damage = Sprite_Damage.new(@viewport, $sv_camera.damager.shift)
end
@damage.push(Sprite_Damage.new(@viewport, $sv_camera.damager.shift))
  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_flug)
for i in [email protected]
   next if @weapons != nil
   @weapons = Sprite_Weapon.new(@viewport, i, battler)
   battler.sv.weapon_index.push(i) if weapon_flug
   return i
end
@weapons.push(Sprite_Weapon.new(@viewport, @weapons.size, battler))
battler.sv.weapon_index.push(@weapons.size - 1) if weapon_flug
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)
   @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 dispose
dispose_effects(@weapons)
dispose_effects(@pictures)
dispose_effects(@back_pic)
dispose_effects(@damage)
  end
  #--------------------------------------------------------------------------
  # ● エフェクト画像の解放
  #--------------------------------------------------------------------------
  def dispose_effects(effects)
for i in 0...effects.size
   effects.dispose if effects != nil
   effects = 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
@battleback_name = battleback_name
@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
back_data_set(0, @move_x, @move_y, false, battleback_name)
  end
  #--------------------------------------------------------------------------
  # ● 背景データをセット
  #--------------------------------------------------------------------------
  def back_data_set(sw_id, move_x, move_y, ba, battleback_name)
@back_data = [] if !@back_data
@back_data.push([sw_id, [move_x, move_y],ba, battleback_name])
  end
  #--------------------------------------------------------------------------
  # ● 背景データを更新
  #--------------------------------------------------------------------------
  def update_back_data
delete = false
for i in 0...@back_data.size
   delete = back_data_off(i) if @back_data[0] > 0 && !$game_switches[@back_data[0]]
   delete = back_data_off(i) if @back_data[0] < 0 && !$sv_camera.switches[@back_data[0].abs]
end
return if !delete
data = @back_data.shift
back_data_on(data[0], data[1][0], data[1][1], data[2], data[3])
  end
  #--------------------------------------------------------------------------
  # ● 背景データの消去
  #--------------------------------------------------------------------------
  def back_data_off(index)
@back_data.delete_at index
return true
  end
  #--------------------------------------------------------------------------
  # ● 背景データの実行
  #--------------------------------------------------------------------------
  def back_data_on(sw_id, move_x, move_y, ba, battleback_name)
data = ["scroll", sw_id, @index, [move_x, move_y],  ba, battleback_name,""]
scroll_set(data)
  end
  #--------------------------------------------------------------------------
  # ● 背景スクロールを初期化
  #--------------------------------------------------------------------------
  def reset_scroll
@scroll_x = 0
@scroll_y = 0
@move_x = 0
@move_y = 0
@reserve = []
  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
$sv_camera.setting(@index, [max_top, max_bottom, max_left, max_right, @base_x, @base_y])
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
return if !bitmap
update_back_data if @back_data && @back_data != []
update_scroll unless @move_x == 0 && @move_y == 0
update_color
update_position
update_back_adjust if @bt_back != nil
set_reserve if @reserve != [] && @reserve_data == nil && @scroll_x == 0 && @scroll_y == 0
  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] *= -1
elsif @color_data[4] == 0
   return @color_data = nil
end
@color_data[3] += @color_data[6]
@color_data[3] = [[@color_data[3], 255].min, 0].max
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
self.visible = @battler.sv.weapon_visible if @battler
  end
  #--------------------------------------------------------------------------
  # ● 背景変更補正画像を更新
  #--------------------------------------------------------------------------
  def update_back_adjust
@bt_adjust[0][0] = 0 if @scroll_x == 0
@bt_adjust[0][1] = 0 if @scroll_y == 0
@bt_adjust[1][0] -= @bt_adjust[2][0] if @scroll_x == 0
@bt_adjust[1][1] -= @bt_adjust[2][1] if @scroll_y == 0
for i in 0...@bt_back.size
   @bt_back.x = -self.ox + @bt_adjust[0] * $sv_camera.zoom
   @bt_back.y = -self.oy + @bt_adjust[1] * $sv_camera.zoom
   @bt_back.zoom_x = self.zoom_x
   @bt_back.zoom_y = self.zoom_y
   @bt_back.z = self.z + 1
   @bt_back.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
end
if @move_reserve != nil && @bt_adjust[0][0] == 0 && @bt_adjust[0][1] == 0
   mirror = $sv_camera.mirror
   mirror = false if !@reserve_data[4]
   @move_x = @reserve_data[3][0]
   @move_x *= -1 if mirror
   @move_y = @reserve_data[3][1]
   @move_reserve = nil
end
if @bt_adjust[1][0] == 0 && @bt_adjust[1][1] == 0
   self.bitmap = @bt_back[1].bitmap
   @bt_back[0].dispose
   @bt_back[1].dispose
   @bt_back = nil
   @reserve_data = nil
end
  end
  #--------------------------------------------------------------------------
  # ● 保留した背景データをセット
  #--------------------------------------------------------------------------
  def set_reserve
@reserve_data = @reserve.shift
@move_reserve = true
name = @reserve_data[5]
name = @battleback_name if name == ""
back_data_set(@reserve_data[1], @reserve_data[3][0], @reserve_data[3][1], @reserve_data[4], name)
back_setting(@reserve_data)
  end
  #--------------------------------------------------------------------------
  # ● 色調変更
  #--------------------------------------------------------------------------
  def color_set
set = $sv_camera.color_set[@index]
$sv_camera.color_set[@index] = nil
set[4] = 1 if set[4] == 0
@color_data = [set[0], set[1], set[2], set[3]/set[4], set[4], set[5], set[3]/set[4]]
  end
  #--------------------------------------------------------------------------
  # ● 背景スクロールをセット
  #--------------------------------------------------------------------------
  def scroll_set(data)
mirror = $sv_camera.mirror
mirror = false if !data[4]
pre_x = @move_x
pre_y = @move_y
@move_x = data[3][0]
@move_x *= -1 if mirror
@move_y = data[3][1]
back_setting(data)
return if @reserve == []
@move_x = pre_x
@move_y = pre_y
name = data[5]
name = @battleback_name if name == ""
back_data_set(data[1], data[3][0], data[3][1], data[4], name)
  end
  #--------------------------------------------------------------------------
  # ● 背景画像の変更をセット
  #--------------------------------------------------------------------------
  def back_setting(data)
return if data[5] == ""
return back_set(data[5]) if data[6] == ""
return if @move_x != 0 && @move_y != 0
# 背景スクロールが途中で変更補正画像がある場合、データを保留
return @reserve.push(data) if @scroll_x != 0 or @scroll_y != 0
mirror = $sv_camera.mirror
mirror = false if !data[4]
@bt_back = []
@bt_back[0] = Sprite.new(viewport)
@bt_back[0].bitmap = Cache.battleback1(data[6]) if @index == 1
@bt_back[0].bitmap = Cache.battleback2(data[6]) if @index == 2
@bt_back[0].mirror = mirror
@bt_back[1] = Sprite.new(viewport)
@bt_back[1].bitmap = Cache.battleback1(data[5]) if @index == 1
@bt_back[1].bitmap = Cache.battleback2(data[5]) if @index == 2
@bt_back[1].mirror = mirror
@bt_adjust = []
sign = -1
if @move_x !=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]
else
   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]
end
@bt_adjust[2] = [@bt_adjust[0][0], @bt_adjust[0][1]]
  end
  #--------------------------------------------------------------------------
  # ● 背景画像を変更
  #--------------------------------------------------------------------------
  def back_set(back_name)
return if back_name == @battleback_name
self.bitmap = Cache.battleback1(back_name) if @index == 1
self.bitmap = Cache.battleback2(back_name) if @index == 2
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  def dispose
bitmap.dispose if bitmap
for i in 0...@bt_back.size do @bt_back.dispose end if @bt_back != nil
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 :damager          # ダメージPOPバトラー
  attr_accessor :program_scroll    # バトルプログラム背景の自動スクロール
  attr_accessor :program_picture # バトルプログラム周期ピクチャ
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize
@switches = []
@max_data = []
@color_set = []
@wait = 0
@win_wait = false
@mirror = false
@damager = []
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 program_setup
@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
  end
  #--------------------------------------------------------------------------
  # ● バトルプログラムのチェック
  #--------------------------------------------------------------------------
  def program_check
for data in @program_base
   next if @played_program.include?(data)
   if program_start?(data[1])
      @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)
      @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?(num)
start = false
start = true if $game_switches[num.abs] && num > 0
start = true if @switches[num.abs] && num < 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]]
   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
  #--------------------------------------------------------------------------
  # ● 背景からカメラの限界値を取得  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
# 上下左右の移動限界距離
base_x = [@max_data[0][5], @max_data[1][5]].min
base_y = [@max_data[0][4], @max_data[1][4]].min
@max_top    = [@max_data[0][0], @max_data[1][0]].max - base_x
@max_bottom = [@max_data[0][1], @max_data[1][1]].min + @max_top
@max_left    = [@max_data[0][2], @max_data[1][2]].max - base_y
@max_right = [@max_data[0][3], @max_data[1][3]].min + @max_left
@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
# ズーム分の中心座標補正
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 reset(time)
move(0, 0, 100, time, true)
  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
update_camera
  end
  #--------------------------------------------------------------------------
  # ● カメラの更新
  #--------------------------------------------------------------------------
  def update_camera
$sv_camera.update
$sv_camera.wait = N03::TURN_END_WAIT if $sv_camera.win_wait
camera_wait
  end
  #--------------------------------------------------------------------------
  # ● カメラウェイト
  #--------------------------------------------------------------------------
  def camera_wait
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
   $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 wait_for_effect
  end
  #--------------------------------------------------------------------------
  # ● ターン開始
  #--------------------------------------------------------------------------
  alias turn_end_scene_battle_n03 turn_end
  def turn_end
$sv_camera.wait = N03::TURN_END_WAIT
camera_wait
N03.camera(nil, N03::BATTLE_CAMERA["ターン開始前"].dup)
turn_end_scene_battle_n03
  end
  #--------------------------------------------------------------------------
  # ● スキル／アイテムの使用 ★再定義
  #--------------------------------------------------------------------------
  def use_item
@log_window.off if !N03::BATTLE_LOG
item = @subject.current_action.item
@log_window.display_use_item(@subject, item)
@subject.use_item(item)
refresh_status
targets = @subject.current_action.make_targets.compact
targets = [@subject] if targets.size == 0
for time in item.repeats.times
   play_sideview(targets, item)
end
$sv_camera.wait = N03::ACTION_END_WAIT if @subject.sv.derivation_skill_id == 0
camera_wait
@log_window.clear
  end
  #--------------------------------------------------------------------------
  # ● スキル／アイテムの効果を適用 ★再定義
  #--------------------------------------------------------------------------
  def apply_item_effects(target, item)
target.item_apply(@subject, item)
refresh_status
  end
  #--------------------------------------------------------------------------
  # ● サイドビューアクション実行
  #--------------------------------------------------------------------------
  def play_sideview(targets, item)
@subject.sv.set_target(targets)
return if @subject.sv.attack_action(item) == nil
@subject.sv.start_action(@subject.sv.attack_action(item))
@targets = targets
loop do
   update_basic
   data = @subject.sv.play_data
   second_targets_set if data[0] == "second_targets_set"
   targets_set       if data[0] == "targets_set"
   immortaling       if data[0] == "no_collapse"
   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 derived_skill if @subject.sv.derivation_skill_id != 0
   break if @subject.sv.action_end
end
unimmortaling if @immortal
  end
  #--------------------------------------------------------------------------
  # ● ターゲットをセカンドターゲットへ
  #--------------------------------------------------------------------------
  def second_targets_set
@targets = @subject.sv.second_targets
@subject.sv.target_battler = @subject.sv.second_targets
  end
  #--------------------------------------------------------------------------
  # ● セカンドターゲットをターゲットへ
  #--------------------------------------------------------------------------
  def targets_set
@subject.sv.second_targets = @subject.current_action.make_targets.compact
@subject.sv.target_battler = @subject.sv.second_targets
  end
  #--------------------------------------------------------------------------
  # ● コラプス禁止
  #--------------------------------------------------------------------------
  def immortaling
@immortal = true
# 全員に不死身付与
for member in $game_party.battle_members + $game_troop.members
   next if member.dead?
   # イベント操作等で不死身設定になっていたら解除を無効にするフラグを立てる
   member.sv.immortal = true if member.state?(N03::IMMORTAL_ID)
   member.add_state(N03::IMMORTAL_ID)
end
  end
  #--------------------------------------------------------------------------
  # ● コラプス許可
  #--------------------------------------------------------------------------
  def unimmortaling
@immortal = false
# 全員の不死身化解除(イベント等で不死身設定がされていれば除く)
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)
   member.add_state(1) if member.hp == 0
   member.perform_collapse_effect if member.dead?
end
  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(target, item) end
@subject.sv.set_damage = false
@subject.sv.damage_anime_data = []
  end
  #--------------------------------------------------------------------------
  # ● ダメージ戦闘アニメ処理
  #--------------------------------------------------------------------------
  def damage_anime(target, item)
@log_window.back_to(1) if @log_window.line_number == 5
@miss = false
invoke_item(target,item)
if target.result.missed
   target.sv.miss_action(@subject, item)
   @miss = true
   return @log_window.display_action_results(target, item)
elsif target.result.evaded
   target.sv.evasion_action(@subject, item)
   @miss = true
   return @log_window.display_action_results(target, item)
end
target.sv.damage_action(@subject, item)
@log_window.display_action_results(target, item)
$sv_camera.damager.push(target)
return if @subject.sv.damage_anime_data == []
target.animation_id = @subject.sv.damage_anime_data[0]
target.animation_mirror = @subject.sv.damage_anime_data[1]
target.sv.anime_no_mirror = @subject.sv.damage_anime_data[2]
target.sv.anime_camera_zoom = @subject.sv.damage_anime_data[3]
  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(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
  #--------------------------------------------------------------------------
  # ● スキル派生
  #--------------------------------------------------------------------------
  def derived_skill
@subject.force_action(@subject.sv.derivation_skill_id, -2)
BattleManager.unshift_action_battlers(@subject)
  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
      @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
      N03.camera(nil, N03::BATTLE_CAMERA["ターン開始後"].dup)
      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
      @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.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                   # サイドビューデータ
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  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_camera.damager.push(self) if @result.hp_damage != 0 or @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]
id = data[1].abs
return false if !actor?
case kind
when  0 ; return weapons.include?($data_weapons[id])
when  1 ; return armors.include?($data_armors[id])
end
  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 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.x = (@ani_ox + cell_data[i, 1] * kind - $sv_camera.x) * camera_zoom if @ani_sprites != nil && cell_data[i, 1] != nil
   @ani_sprites.y = (@ani_oy + cell_data[i, 2] - $sv_camera.y) * camera_zoom if @ani_sprites != nil && cell_data[i, 2] != nil
end
  end
  #--------------------------------------------------------------------------
  # ● アニメーション元の座標をセット
  #--------------------------------------------------------------------------
  def ani_ox_set
@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?
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
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] - $sv_camera.x) * $sv_camera.zoom
      sprite.y = (@ani_oy + cell_data[i, 2] - $sv_camera.y) * $sv_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] - $sv_camera.x) * $sv_camera.zoom
      sprite.y = (@ani_oy + cell_data[i, 2] - $sv_camera.y) * $sv_camera.zoom
      sprite.angle = cell_data[i, 4]
      sprite.mirror = (cell_data[i, 5] == 1)
   end
   sprite.z = self.z + 300 + 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_flug = true
se_flug = @se_flug if @se_flug != nil
@battler.sv.timing.push([se_flug, timing.dup])
  end
  #--------------------------------------------------------------------------
  # ● SE とフラッシュのタイミング処理
  #--------------------------------------------------------------------------
  alias animation_process_timing_sprite_base_n03 animation_process_timing
  def animation_process_timing(timing)
return other_process_timing(timing) if @next != nil
animation_process_timing_sprite_base_n03(timing)
  end
end

#==============================================================================
# ■ Sprite_Battler
#------------------------------------------------------------------------------
# 　バトラー表示用のスプライトです。
#==============================================================================
class Sprite_Battler < Sprite_Base
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  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
   @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 [email protected]?
update_bitmap_actor if @battler.actor?
update_src_rect
update_color
  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_flug = @battler.sv.graphic_mirror_flug
   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_flug = @battler.sv.graphic_mirror_flug
   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?
self.opacity = 0 unless @battler_visible
self.opacity = 255 if @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 [email protected]?
end
self.src_rect.set(@battler.sv.sx, @battler.sv.sy, @battler.sv.cw, @battler.sv.ch)
@battler.sv.opacity = 0 if self.opacity == 0 && @battler.sv.opacity_data == []
self.opacity = @battler.sv.opacity
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
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_flug
self.mirror = [email protected] if @graphic_mirror_flug
  end
  #--------------------------------------------------------------------------
  # ● 影グラフィックの更新
  #--------------------------------------------------------------------------
  def update_shadow
@shadow.visible = @battler.sv.shadow_visible
@shadow.opacity = @battler.sv.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 = @battler.sv.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] *= -1
elsif @color_data[4] == 0
   @battler.sv.color = []
   return @color_data = nil
end
@color_data[3] += @color_data[6]
@color_data[3] = [[@color_data[3], 255].min, 0].max
@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 = 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 [email protected]
   mirage_body(@mirages, @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 * @battler.sv.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
  end
  #--------------------------------------------------------------------------
  # ● バトラー入れ替え
  #--------------------------------------------------------------------------
  def remove
@battler.sv.start_action(@battler.sv.remove_action)
$sv_camera.wait = -1
@battler.sv.add_action("画像変更フラグ")
  end
  #--------------------------------------------------------------------------
  # ● バトラー加入
  #--------------------------------------------------------------------------
  def join(join_battler)
$sv_camera.wait = 20
@battler = join_battler
return reset_shadow if !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
  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_flug, data)
@ani_rate = 4
data.se.play if se_flug
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
@color_data = [set[0], set[1], set[2], set[3]/set[4], set[4], set[5], set[3]/set[4]]
  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
  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 = []
@party_index = []
@remove_member = []
@join_member = []
@change_index = []
for i in 0...$game_party.max_battle_members
   @actor_sprites = Sprite_Battler.new(@viewport1, $game_party.members)
   @party_index.push($game_party.members)
end
@effect_sprites = Spriteset_Sideview.new(@viewport1)
  end
  #--------------------------------------------------------------------------
  # ● アクタースプライトの更新 ★再定義
  #--------------------------------------------------------------------------
  def update_actors
party_setup if @remove_data != []
@actor_sprites.each_with_index do |sprite, i|
   if @party_index != $game_party.members
      sprite.remove if @party_index != nil
      @remove_member.push(@party_index)
      @join_member.push($game_party.members)
      @change_index.push(i)
      @party_index = $game_party.members
   end
   sprite.update
end
@effect_sprites.update
update_program
  end
  #--------------------------------------------------------------------------
  # ● パーティ編成
  #--------------------------------------------------------------------------
  def party_setup
for i in 0...@remove_member.size
   # 新規加入の場合
   if @remove_member == nil
      @actor_sprites[@change_index].join(@join_member)
      @remove_member.delete_at i
      @join_member.delete_at i
      @change_index.delete_at i
      break
   # 入れ替えの場合
   elsif @remove_member.sv.change_up
      member = @remove_member
      @actor_sprites[@change_index].join(@join_member)
      @remove_member.delete_at i
      @join_member.delete_at i
      @change_index.delete_at i
      member.sv.change_up = false if !@remove_member.include?(member)
      break
   end
end
  end
  #--------------------------------------------------------------------------
  # ● バトルプログラムの更新
  #--------------------------------------------------------------------------
  def update_program
return if $sv_camera.program_scroll == []
for data in  $sv_camera.program_scroll
   @back1_sprite.scroll_set(data) if data[2] == 1
   @back2_sprite.scroll_set(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
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  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 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
  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アクション設定
#------------------------------------------------------------------------------
# 　サイドビューバトル全般のセッティングやアクションを作成します
#==============================================================================
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]]
  # 行動終了時のウエイト(待ち時間・単位は1フレーム)
  ACTION_END_WAIT = 10
  # ターン終了時のウエイト(待ち時間・単位は1フレーム)
  TURN_END_WAIT = 15
  # 敵の不意打ち時にバックアタック(左右反転)を許可するならtrue しないならfalse
  BACK_ATTACK = true
  # 味方バトラーがダメージを受けた時、デフォルトのエフェクトを採用するならtrue
  ACTOR_DAMAGE = false
  # 敵バトラーがダメージを受けた時、デフォルトのエフェクトを採用するならtrue
  ENEMY_DAMAGE = false
  # 敵バトラーのX座標、回転計算、戦闘アニメを自動で反転させるならtrue
  ENEMY_MIRROR = true
  # コラプス禁止処理に使う、データベースの不死身ステートID
  IMMORTAL_ID = 10

  # バトルログ(戦闘の進行を実況表示するウィンドウ)を表示させるならtrue
  BATTLE_LOG = true
  # ダメージ数字をPOPさせるならtrue
  DAMAGE_POP = true
  # ステート付加をPOPさせるならtrue
  # (アイコンがPOPしますがSystemフォルダにステート名の画像があればそれがPOPします)
  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"は指定のないBattlebacks1画像を一括設定する項目です
  # 壁背景ﾌｧｲﾙ名…設定する壁背景(Battlebacks2)画像ﾌｧｲﾙ名。
  #             "全Battlebacks2"は指定のないBattlebacks2画像を一括設定する項目です
  # 座標調整…[X軸, Y軸]
  # 拡大率……[横拡大率, 縦拡大率]
  # ｼｪｲｸ可……シェイクアクションで揺れを許可するならtrue　しないならfalse
  # ｽｲｯﾁﾄﾘｶﾞｰ…戦闘開始時に自動でONにするｹﾞｰﾑｽｲｯﾁ番号。ﾏｲﾅｽでｻｲﾄﾞﾋﾞｭｰ専用ｽｲｯﾁがON
  #          背景とﾊﾞﾄﾙﾌﾟﾛｸﾞﾗﾑをセットで管理したい場合などに利用します
  #          スイッチ操作をしないなら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 = {

#--------------------------------------------------------------------------
# ● バトラーアニメ設定
#--------------------------------------------------------------------------
  # デフォルトのキャラチップは一つの画像ファイルに複数のキャラが配置されています
  # キャラチップを利用する場合、追加画像はキャラの画像配置に合うようにしてください
  # 一人のキャラで一つの画像を用いる(ファイルの頭に$がある)場合は特に問題ありません

  # ｲﾝﾃﾞｯｸｽ…利用するバトラー画像ﾌｧｲﾙの後ろに付くｲﾝﾃﾞｯｸｽ名。
  #       ｻｲﾄﾞﾋﾞｭｰのﾊﾞﾄﾗｰはｱｸﾀｰの場合だとｷｬﾗｸﾀｰﾌｧｲﾙ名を参照しますが
  #       ｲﾝﾃﾞｯｸｽが付くと、ｷｬﾗｸﾀｰﾌｧｲﾙ名+ｲﾝﾃﾞｯｸｽ名の画像ﾌｧｲﾙを参照します
  #       例)Actor1のﾊﾞﾄﾗｰがｲﾝﾃﾞｯｸｽ"_1"のｱﾆﾒを実行する場合の参照ﾌｧｲﾙはActor1_1
  #       ｷｬﾗﾁｯﾌﾟを利用する場合のｱﾆﾒのｲﾝﾃﾞｯｸｽは""になります
  #       アクターはCharactersフォルダ、エネミーはBattlersフォルダに画像を入れます
  #
  # 縦ｾﾙ…画像ﾌｧｲﾙのセルの縦位置。上から0～3と続きます。数に制限はありません
  #    ｾﾙ数の設定はﾊﾞﾄﾗｰ設定で行ってください
  # 横ｾﾙ…画像ﾌｧｲﾙのセルの横位置で、再生開始セル。左から0～3と続きます。
  #    ｱﾆﾒはこの横ｾﾙの左から右へと再生します。ｾﾙ数に制限はありません
  # ﾊﾟﾀｰﾝ… 0:セル固定 1:片道　2:往復　3:片道ループ　4:往復ループ
  # 速度…アニメの更新速度。数字が低いほど早く更新します
  # Z軸…手前に表示するならプラス。通常は画面下ほど手前に表示されます
  # ｳｴｲﾄ…アニメパターンが最後まで再生されてから次の行動に移るならtrue
  # 影…影グラフィックを表示するならtrue、しない場合はfalse
  # 武器…武器を表示する場合は武器アクション名を。しない場合は""
  #    武器アクションはいくつでも同時追加可能で、追加分は配列の後ろに入れていきます

  #―ｱｸｼｮﾝ名(待機系)― 判別ｲﾝﾃﾞｯｸｽ  縦ｾﾙ横ｾﾙﾊﾟﾀｰﾝ速度  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, "" ],

  #―ｱｸｼｮﾝ名(移動系)― 判別ﾌｧｲﾙNo 縦ｾﾙ横ｾﾙﾊﾟﾀｰﾝ速度  Z軸ｳｴｲﾄ影武器
  "左向き移動"    => ["motion", "", 1, 0, 4, 6, 100, true, true, "" ],
  "右向き移動"    => ["motion", "", 2, 0, 4, 6, 100, true, true, "" ],

  #―ｱｸｼｮﾝ名(ﾎﾟｰｽﾞ系)― 判別ﾌｧｲﾙNo 縦ｾﾙ横ｾﾙﾊﾟﾀｰﾝ速度  Z軸ｳｴｲﾄ影武器

  #―ｱｸｼｮﾝ名(攻撃系)― 判別ﾌｧｲﾙNo 縦ｾﾙ横ｾﾙﾊﾟﾀｰﾝ速度  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, "掲げ" ],
  "弓撃ち"       => ["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のみの移動に
  # 速度…1ﾌﾚｰﾑで移動するﾋﾟｸｾﾙ数。数値をﾏｲﾅｽにすると時間指定になり、移動完了までの総ﾌﾚｰﾑ数になります
  # ｶｰﾌﾞ…移動時の軌道が正は上、負は下にカーブします。
  # ｼﾞｬﾝﾌﾟ…ｼﾞｬﾝﾌﾟ放物線軌道。[ｼﾞｬﾝﾌﾟ開始から頂点までの軌道, 頂点から着地までの軌道]
  # ｱﾆﾒ…その移動に利用するバトラーアニメのアクション名。

  #――ｱｸｼｮﾝ名(ｼｽﾃﾑ系)―― 判別目標 X軸  Y軸  H軸速度  ｶｰﾌﾞ  ｼﾞｬﾝﾌﾟｱﾆﾒ
  "戦闘前の味方配置" => ["move",-7, 160, 0, 0,  0, 0, [  0,  0], "左向き移動"],
  "退場"             => ["move",-7, 160, 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, 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…バトラーと同じ(画像下と縦半分)]
  # 反転…trueにすると画像を反転して表示
  # 拡大…[X軸拡大率, Y軸拡大率] 小数点でも受け付けます
  # Z軸…画像をキャラより手前に表示するならtrue
  # 逆手…盾画像、もしくは二刀流時の左(項目だと下)の武器画像を表示
  #    アイコンを利用しない場合、盾の画像はﾊﾞﾄﾗｰ設定の盾の項目で行います
  # 更新…-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。0はｱﾆﾒ非表示。[移動させるｱﾆﾒID, ヒット時のｱﾆﾒID]
  # 始…ｱﾆﾒ移動の開始位置。ﾏｲﾅｽにすると、複数ﾀｰｹﾞｯﾄでも一個のアニメだけ実行
  #    [0=自分] [1=ﾀｰｹﾞｯﾄ] [2=敵全] [3=味方全] [4=敵味方全] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ] [6=画面]
  # 後…ｱﾆﾒ移動の終了位置。ﾏｲﾅｽにすると、複数ﾀｰｹﾞｯﾄでも一個のアニメだけ実行
  #    [0=自分] [1=ﾀｰｹﾞｯﾄ] [2=敵全] [3=味方全] [4=敵味方全] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ] [6=画面]
  # 始調整…移動開始座標の微調整。[X軸, Y軸] エネミーはX軸が自動で逆計算に
  # 後調整…移動終了座標の微調整。[X軸, Y軸] エネミーはX軸が自動で逆計算に
  # 速度…1ﾌﾚｰﾑに移動するX軸ﾋﾟｸｾﾙ数。マイナスにすると時間扱いになり、距離によって速度が変わります
  # ﾀｲﾌﾟ…移動後の処理。[0=消える(ミス時は自動で貫通に変化)] [1=貫通] [2=消える(ミス時も消える)]
  # 軌道…移動の軌道。[開始から頂点までの軌道, 頂点から終了までの軌道]
  # Z軸…アニメや武器をキャラより手前に表示するならtrue
  # ｳｴｲﾄ…アクションが終わるまで次のアクションに移行しないならtrue [移動させるアニメのウエイト, ヒット時アニメのウエイト]
  # ﾀﾞﾒｰｼﾞ…目標到達時にダメージ計算を適用するならtrue
  # ﾎｰﾐﾝｸﾞ…移動するﾀｰｹﾞｯﾄに対してﾎｰﾐﾝｸﾞするならtrue。しないならfalse
  # ｶﾒﾗ…カメラのズームに合わせてアニメを拡大縮小するならtrue
  # ﾙｰﾌﾟ…移動させるアニメの再生が終わった時、最初にループさせるならtrue
  # 反転不可…いかなる場合でもアニメを反転させないならtrue
  # 武器…武器アクション名を入れます。利用しないなら""

  #――ｱｸｼｮﾝ名――    判別    ID 始後  始調整後調整  速度ﾀｲﾌﾟ  軌道 Z軸    ｳｴｲﾄ    ﾀﾞﾒｰｼﾞ  ﾎｰﾐﾝｸﾞｶﾒﾗﾙｰﾌﾟ反転不可武器
  "矢発射"       => ["m_a",[ 0,-1], 0, 1, [ 0, 0], [ 0, 0], 10,  2, [-3,-3], true, [ true, true],  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=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ]
  # ﾎｰﾐﾝｸﾞ… 対象の座標移動にアニメが追尾するならtrue
  # ｳｴｲﾄ…アニメ表示が終わるまで待つならtrue
  # ﾀﾞﾒｰｼﾞ…ダメージ計算を適用するならtrue
  # ｶﾒﾗ…カメラのズームに合わせてアニメを拡大縮小するならtrue
  # 反転不可…いかなる場合でもアニメを反転させないならtrue
  # 反転…アニメを反転させるならtrue

  #―ｱｸｼｮﾝ名(ﾀﾞﾒｰｼﾞ系)―    判別    ID 対象  ﾎｰﾐﾝｸﾞｳｴｲﾄ  ﾀﾞﾒｰｼﾞｶﾒﾗ反転不可  反転
  "対象アニメ武器"    => ["anime",  -1,  1, false, false,  true,  true, false,  false],
  "対象アニメ武器WT" => ["anime",  -1,  1, false,  true,  true,  true, false,  false],
  "対象アニメ武器LWT" => ["anime",  -2,  1, false,  true,  true,  true, false,  false],
  "対象アニメ"       => ["anime",  -3,  1, false, false,  true,  true, false,  false],
  "対象アニメWT"       => ["anime",  -3,  1, false,  true,  true,  true, false,  false],

  #――ｱｸｼｮﾝ名(自身系)―― 判別    ID 対象  ﾎｰﾐﾝｸﾞｳｴｲﾄ  ﾀﾞﾒｰｼﾞｶﾒﾗ反転不可  反転
  "魔法詠唱中"       => ["anime", 113,  0,  true,  true, false,  true, false,  false],
  "特技待機中"       => ["anime", 114,  0,  true,  true, false,  true, false,  false],
  "魔法発動アニメ"    => ["anime", 115,  0, false,  true, false,  true, false,  false],
  "特技発動アニメ"    => ["anime", 116,  0, false,  true, false,  true, false,  false],

#--------------------------------------------------------------------------
# ● カメラワーク  画面のズームやスクロールを行います
#--------------------------------------------------------------------------
  # 対象…移動やｽﾞｰﾑの対象
  #    [0=自分] [1=ﾀｰｹﾞｯﾄ] [2=敵全] [3=味方全] [4=敵味方全] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ] [6=画面]
  # 調整座標…カメラ座標の最終地点微調整 [X軸(ﾌﾟﾗｽで画面→), Y軸(ﾌﾟﾗｽで画面↓)]
  # 時間…カメラワークにかける時間
  # ｽﾞｰﾑ…カメラのズーム率(%)。100でズームなし。
  # ｳｴｲﾄ…カメラワークが終わるまで待つならtrue。待たないならfalse

  #――ｱｸｼｮﾝ名――    判別対象  調整座標ｽﾞｰﾑ  時間  ｳｴｲﾄ
  "カメラリセット"=> ["camera", 6, [ 0, 0], 100,  30, false],
  "ズームイン" => ["camera", 0, [ 0, 0], 120,  40, false],
  "ズームアウト"  => ["camera", 6, [ 0, 0],  80,  40, false],

#--------------------------------------------------------------------------
# ● 画面のシェイク  画面を揺らします。空中座標(H座標が0以上)のバトラーは揺れません
#--------------------------------------------------------------------------
  # 方向…揺れる方向 [横,縦] 数値が大きいほど揺れ幅は大きくなります
  # 速度…揺れの速度。小さいほど早く揺れます
  # 時間…揺れの続く時間。揺れ幅は時間と共に弱まっていきます
  # ｳｴｲﾄ…シェイクが終わるまで待つならtrue。待たないならfalse

  #――ｱｸｼｮﾝ名――    判別    方向速度  時間  ｳｴｲﾄ
  "シェイク小"    => ["shake", [  0, 4],  2, 16, false],
  "シェイク中"    => ["shake", [  0, 6],  3, 30, false],
  "シェイク大"    => ["shake", [  0,10],  3, 40, false],

#--------------------------------------------------------------------------
# ● 画面色調変更　背景やバトラーの色調を変更します
#--------------------------------------------------------------------------
  # 対象…色調変更の対象
  #    [0=自分] [1=ﾀｰｹﾞｯﾄ] [2=敵全] [3=味方全] [4=敵味方全] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ]
  #    [6=背景] [7=自分+ﾀｰｹﾞｯﾄ] [8=自分以外] [9=自分+ﾀｰｹﾞｯﾄ以外] [10=全て]
  # 色調レベル…[ R, G, B, ｱﾙﾌｧ(色の強さ), 変更時間, ※戻り]
  #          ※戻り…変更完了してから元の色に戻す時間。戻さないなら0
  # ｳｴｲﾄ…色調変更が終わるまで待つならtrue。待たないならfalse

  # 変更名                      判別対象    R, G, B,ｱﾙﾌｧ  時間戻り  ｳｴｲﾄ
  "色調初期化"             => ["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", 9, [ 0, 0, 0, 255,  30, 0], false],

#--------------------------------------------------------------------------
# ● 残像  バトラーの移動に残像を残します
#--------------------------------------------------------------------------
  # 数…残像数。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が完全に不透明な状態
  # 終了…変更終了時の透明度
  # 影…影も同じ透明度操作をするならtrue
  # 武器…武器も同じ透明度操作をするならtrue
  # ﾙｰﾌﾟ…透明度変更が終了した後、操作を自動で逆転させ続けるならtrue
  # ｳｴｲﾄ…操作終了まで次のアクションに移行せず待つならtrue

  #――ｱｸｼｮﾝ名――  　    判別時間  開始  終了影武器ﾙｰﾌﾟ  ｳｴｲﾄ
  "逃走透明"       => ["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],

#--------------------------------------------------------------------------
# ● ふきだしアニメ　イベントに使うふきだしアイコンを表示
#--------------------------------------------------------------------------
  # 種類…ふきだしの種類(縦位置)を0～9で指定
  # 速度…更新速度。セルは2コマ目から再生されます
  # ｻｲｽﾞ…ふきだしのサイズ

  # ふきだし名　　    判別    種類速度  ｻｲｽﾞ
  "状態異常/汎用" => ["balloon", 6,  10,  0.6],
  "状態異常/ピンチ" => ["balloon", 5,  10,  0.6],
  "状態異常/睡眠" => ["balloon", 9,  10,  0.6],

#--------------------------------------------------------------------------
# ● ピクチャの表示  カットインなどに
#--------------------------------------------------------------------------
  # 番号…使用するﾋﾟｸﾁｬの番号。ﾋﾟｸﾁｬを管理するための番号です。何枚でも表示できます
  #    フルアクションが終了すると自動で消去(Bitmap解放)されます
  # 開始座標…移動開始位置。ﾋﾟｸﾁｬの左上を原点とします。[X軸, Y軸]
  #          既にﾋﾟｸﾁｬがある場合、[]にすると開始座標はその場所になります
  # 終了座標…移動終了位置。開始位置と同じ値にすると移動せず表示のみになります
  #          ﾌﾟﾚｰﾝ使用の場合、開始と終了を[]にすると移動速度を維持します
  # 時間…移動時間。0でピクチャを消去します
  # Z軸…ﾋﾟｸﾁｬのZ座標。100以上にするとウインドウより手前に表示されます
  # 透明度…透明度設定。[開始時の透明度, 1フレームごとに加算される透明度]
  # ﾌﾟﾚｰﾝ使用…ﾌﾟﾚｰﾝｸﾗｽ(画像がタイル状に並ぶ画像)を使用する場合の矩形。[X軸,Y軸]
  #          ﾌﾟﾚｰﾝを使用しない場合は[]
  # BA反転…バックアタック時に画像反転とX座標移動を逆にするならtrue
  #       ﾌﾟﾚｰﾝ使用時の画像はtrueでも反転せず、X座標移動のみ逆になります
  # ﾋﾟｸﾁｬﾌｧｲﾙ名…ピクチャフォルダ内のファイル名。

  #                   判別  番号  開始座標    終了座標時間 Z軸透明度ﾌﾟﾚｰﾝ使用  BA反転ﾋﾟｸﾁｬﾌｧｲﾙ名
  "カットイン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=ﾗﾝﾀﾞﾑ1体] [2=自分を除く]
  # 操作…ステートを付与するなら"+"　解除するなら"-"
  # ｽﾃｰﾄID…操作するステートのID

  # ステート付与名          判別  対象拡張操作ｽﾃｰﾄID
  "戦闘不能付与"       => ["sta",  0, 0, "+", 1],

#--------------------------------------------------------------------------
# ● FPS(ゲーム全体のスピード)変更  アクションの細部チェック用
#--------------------------------------------------------------------------
  # ｹﾞｰﾑｽﾋﾟｰﾄﾞ…60がデフォルトで、低くなるほどスローになります。　

  #――ｱｸｼｮﾝ名―― 判別  ｹﾞｰﾑｽﾋﾟｰﾄﾞ
  "スロー再生" => ["fps",  15],
  "通常再生"    => ["fps",  60],

#--------------------------------------------------------------------------
# ● バトラー画像変更  バトラー画像の参照先ファイルを変更します
#--------------------------------------------------------------------------
  # 維持…アクターの場合、戦闘後も変更を維持するならtrue
  # ｲﾝﾃﾞｯｸｽ…アクターの場合、歩行グラのどの矩形かを設定します
  # ﾌｧｲﾙ名…変更する画像ﾌｧｲﾙ名。アクターはCharactersフォルダ、
  #       エネミーはBattlersフォルダを参照します
  # 顔ｸﾞﾗ…アクターの場合、戦闘後の顔ｸﾞﾗも変更するなら[顔ｸﾞﾗｲﾝﾃﾞｯｸｽ, ﾌｧｲﾙ名]
  #       変更しないなら[]

  #―――ｱｸｼｮﾝ名―――    判別    維持  ｲﾝﾃﾞｯｸｽ  ﾌｧｲﾙ名       顔ｸﾞﾗ
  "オオカミに変身" => ["change",  true, 6, "Animal", [0, "Actor4"]],

#--------------------------------------------------------------------------
# ● スキル派生  アクションを中断し、別のスキルに派生させます
#--------------------------------------------------------------------------
  # 習得…派生するスキルが未修得でも実行可能ならtrue
  # ｺｽﾄ条件…派生するスキルのコストが足りなくても実行可能ならtrue
  # ｽｷﾙ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"],

#--------------------------------------------------------------------------
# ● ゲームスイッチの操作
#--------------------------------------------------------------------------
  # ｽｲｯﾁNo…何番のスイッチを操作するか
  # ON/OFF…ONにするならtrue、OFFにするならfalse
  #
  #――ｱｸｼｮﾝ名――    判別    ｽｲｯﾁNo ON/OFF
  "スイッチNo1/ON"  => ["switch", 1, true],

#--------------------------------------------------------------------------
# ● ゲーム変数の操作
#--------------------------------------------------------------------------
  # 変数No…何番の変数を操作するか
  # 操作…[0=代入] [1=加算] [2=減算] [3=乗算] [4=除算] [5=剰余]
  # ｵﾍﾟﾗﾝﾄﾞ…演算の対象となる数値を指定します。マイナスにすると、その数字の
  #       絶対値の変数Noに格納されている数値が演算の対象となります
  #
  # ――ｱｸｼｮﾝ名―― 　　  判別    変数No  操作  ｵﾍﾟﾗﾝﾄﾞ
  "変数No1/+1"    => ["variable", 1,    1,    1],

#--------------------------------------------------------------------------
# ● 条件分岐 (ゲームスイッチ) 条件を設定し、アクションを分岐させます
#--------------------------------------------------------------------------
  # ｽｲｯﾁNo…何番のスイッチを参照するか
  # 条件…ONならtrue、OFFならfalse
  # 分岐…条件を満たした場合の分岐処理。満たさない場合はその逆の処理がされます
  #    [0=次のｱｸｼｮﾝを実行] [1=次のｱｸｼｮﾝをｷｬﾝｾﾙ] [2=ﾌﾙｱｸｼｮﾝ終了]
  #
  #―――ｱｸｼｮﾝ名―――    判別  ｽｲｯﾁNo  条件  分岐
  "スイッチNo1=ONで実行" => ["n_1", 1, true, 0],

#--------------------------------------------------------------------------
# ● 条件分岐 (ゲーム変数)
#--------------------------------------------------------------------------
  # 変数No…何番の変数を参照するか
  # 数値…条件となる数字を入れます。ﾏｲﾅｽでその絶対値の変数に格納された数値を参照します
  # 条件…参照した変数が条件の数字と比べて…[0=同値] [1=少ない] [2=多い]
  # 分岐…条件を満たした場合の分岐処理。満たさない場合はその逆の処理がされます
  #    [0=次のｱｸｼｮﾝを実行] [1=次のｱｸｼｮﾝをｷｬﾝｾﾙ] [2=ﾌﾙｱｸｼｮﾝ終了]
  #
  #―――ｱｸｼｮﾝ名―――    判別  変数No 数値  条件  分岐
  "変数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
  # 条件…[0=装備している] [1=装備していない]
  # 人数…上の条件となる必要人数。条件対象がグループの場合、0でグループ全員の数になります
  # 分岐…条件を満たした場合の分岐処理。満たさない場合はその逆の処理がされます
  #    [0=次のｱｸｼｮﾝを実行] [1=次のｱｸｼｮﾝをｷｬﾝｾﾙ] [2=ﾌﾙｱｸｼｮﾝ終了]
  #
  #―――ｱｸｼｮﾝ名―――    判別  対象  種類 ID 条件  人数  分岐
  "ハンドアクス限定"    => ["n_6",  0, 0, 1, 0, 1, 0],

#--------------------------------------------------------------------------
# ● 条件分岐 (スクリプト)　
#--------------------------------------------------------------------------
  # 分岐…条件を満たした場合の分岐処理。満たさない場合はその逆の処理がされます
  #    [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", 0,  "@battler.dual_wield?"],

#--------------------------------------------------------------------------
# ● セカンドターゲット操作
#--------------------------------------------------------------------------
  # セカンドターゲットとは、通常のターゲットとは別の独立したターゲット情報です
  # 何も操作しない場合、通常ターゲットと同じ対象がセットされています
  #
  # 対象…[0=自分] [1=ターゲット] [2=敵全体] [3=味方全体] [4=敵味方全体] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ]
  #
  # INDEX…対象をﾊﾟｰﾃｨのｲﾝﾃﾞｯｸｽ(並び順)で絞込みます INDEX = [ｲﾝﾃﾞｯｸｽ, 判別]
  #       ｲﾝﾃﾞｯｸｽ…ﾊﾟｰﾃｨのｲﾝﾃﾞｯｸｽ数値
  #       判別…数値の条件 [0=絞込まない] [1=そのｲﾝﾃﾞｯｸｽが対象に] [2=そのｲﾝﾃﾞｯｸｽを排除]
  #
  # ID…対象をｱｸﾀｰ(ｴﾈﾐｰ)IDで絞込むならIDの数字を入れる。0で絞込まない
  #    ﾏｲﾅｽにするとその絶対値のIDが排除条件になります
  #
  # ｽﾃｰﾄ…対象を現在付加しているｽﾃｰﾄIDで絞込むならｽﾃｰﾄIDの数字を入れる。0で絞込まない
  #    ﾏｲﾅｽにすると付加していないことが条件になります
  #
  # ｽｷﾙ…対象を使用可能なｽｷﾙIDで絞込むならｽｷﾙIDの数字を入れる。0で絞込まない
  #    ﾏｲﾅｽにすると使用不可能が条件になります
  #
  # ﾊﾟﾗﾒｰﾀ…対象のパラメータを条件に絞込みますﾊﾟﾗﾒｰﾀ = [種別, 数値, 判別]
  #       種別…[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を入れます。0で絞込まない
  #          ﾏｲﾅｽにすると未装備が条件になります
  #
  # 拡張…上で設定した対象をさらに拡張します [0=拡張なし] [1=ランダム1体]  [2=自分を除く]
  # 操作…[0=操作しない] [1=通常ﾀｰｹﾞｯﾄをｾｶﾝﾄﾞﾀｰｹﾞｯﾄに変更]  [2=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ・通常ﾀｰｹﾞｯﾄを初期化]

  #――ｱｸｼｮﾝ名――    判別対象  INDEX  ID  ｽﾃｰﾄｽｷﾙﾊﾟﾗﾒｰﾀ    装備拡張操作
  "全域化"       => ["s_t", 4, [ 0, 0], 0, -1, 0, [ 0, 0, 0], [ 0, 0],  0, 1],

#--------------------------------------------------------------------------
# ● スクリプトの操作
#--------------------------------------------------------------------------
  # スクリプトを実行。サンプルのp = 1 の部分にevalで実行するスクリプトを入れます
  #
  #―――ｱｸｼｮﾝ名―――
  "テストスクリプト" => ["p = 1 "],

#--------------------------------------------------------------------------
# ● その他　設定項目なしでフルアクションに入れます
#--------------------------------------------------------------------------
  # 反転…画像と武器アニメを反転します。再度反転させるかフルアクション終了で反転解除
  # 武器消去…表示中の武器画像を消去します
  # 武器消去解除…消去した武器画像を表示します
  # 敵コラプス…崩御エフェクトを実行します。主に敵の戦闘不能に使用します
  # コラプス禁止…対象のHPが0になった場合のコラプスを禁止します。連続攻撃開始時などに
  # コラプス禁止解除…コラプス禁止を解除します。連続攻撃の終わりなどに。入れなくても行動終了時にコラプス許可になります
  # 待機キャンセル…待機アクションを行わないようになります。戦闘イベントでの演出などに
  # 待機キャンセル解除…待機キャンセルを解除し、待機アクションを行います
  # 初期位置変更…元の座標(初期位置)を現在の座標に変更します
  # 初期位置変更解除…初期位置変更で変更した座標を元に戻します
  # 強制…この次にある行動をターゲットに強制させます(リアクション)
  # 強制2…この次にある行動をセカンドターゲットに強制させます(リアクション)
  # 次の行動者へ…戦闘行動が終了したとみなし、直後に次のキャラが行動開始します
  # 個別開始…複数ﾀｰｹﾞｯﾄ攻撃を個別で処理する場合の、リピート行動開始の目印です
  # 個別終了…複数ﾀｰｹﾞｯﾄ攻撃を個別で処理する場合の、リピート行動終了の目印です
  # ループ開始…"ループ開始"と"ループ終了"の間のアクションを永遠に繰り返します
  # ループ終了…"ループ開始""ループ終了"は主にコマンド入力後の待機アクションに利用します
  # 画像変更フラグ…※システムに利用しているので、使わないでください

  #―――ｱｸｼｮﾝ名―――    判別
  "反転"             => ["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"],
  "画像変更フラグ" => ["set_change"],

#--------------------------------------------------------------------------
# ● ウエイト　次のアクションに行かずに待つ時間
#--------------------------------------------------------------------------
  # アクションで数値のみの場合、それがそのままウエイト時間となります。
  # (例) "20" …次のアクションに行かずに20フレーム待つ
  #
  # 数値をマイナスにするとランダムウエイトとなり、その数値の0～絶対値の間で
  # ランダムにウエイト時間が決定されます。
  # (例) "-20" …ランダムで0～20フレーム待つ

#--------------------------------------------------------------------------
# ● ショートカットコマンド
#--------------------------------------------------------------------------
  # 通常は設定したアクション名をフルアクション配列に入れて行動を作りますが
  # アクション設定せず直接コマンドを記述して、作業を短縮できるものがあります
  # 頻繁に利用するものはこのｼｮｰﾄｶｯﾄを使うと登録ｱｸｼｮﾝが増えないのでお勧めです
  #
  # [戦闘アニメ]
  # (例) "anime(20)" …データベース20番のアニメをターゲットに実行(ウエイトあり)
  # (例) "anime(20,false)" …データベース20番のアニメをターゲットに実行(ウエイトなし)
  # (例) "anime_me(20)" …データベース20番のアニメを自分に実行(ウエイトあり)
  # (例) "anime_me(20,false)" …データベース20番のアニメを自分に実行(ウエイトなし)
  #
  # [効果音(SE)]
  # (例) "se('Bow1')" …ファイル名がBow1のSEを鳴らします
  # (例) "se('Bow1',50)" …ファイル名がBow1のSEをピッチ50で鳴らします
  #
  # [ターゲットへアクション(フルアクション)を強制]
  # (例) "target('ダメージのけぞり')" …ﾀｰｹﾞｯﾄに"ダメージのけぞり"のｱｸｼｮﾝを強制します
  # (例) "target2('被ダメージ')" …ｾｶﾝﾄﾞﾀｰｹﾞｯﾄに"被ダメージ"のﾌﾙｱｸｼｮﾝを強制します

  }
#==============================================================================
# ■ フルアクション
#------------------------------------------------------------------------------
# 　アクションを組み合わせたもので、行動は左側から順番に行われます。
# フルアクションの中にフルアクションを入れることも可能で、アクションのパーツ化や
# 条件分岐の次にフルアクションを置く等の使い方が便利です
#==============================================================================
  FULLACTION = {

  # ―――待機系―――
  "通常待機"       => ["待機"],
  "通常待機固定" => ["待機固定WT"],
  "ピンチ待機"    => ["状態異常/ピンチ","ピンチ色調","待機","待機"],
  "毒待機"       => ["状態異常/汎用","毒色調","待機","待機"],
  "睡眠待機"       => ["状態異常/睡眠","倒れ","倒れ"],
  "汎用状態異常待機"=> ["状態異常/汎用","汎用状態異常色調","待機","待機"],
  "様子見"       => ["待機","60"],
  "戦闘不能"       => ["倒れ"],

  # ――システム系――
  "戦闘開始味方" => ["戦闘前の味方配置","座標リセット左向き"],
  "味方退場"       => ["退場"],
  "逃走"          => ["退場"],
  "敵逃走"       => ["対象アニメ","逃走透明","退場"],
  "逃走失敗"       => ["逃走途中","一歩後移動","座標リセット左向き"],
  "コマンド入力" => ["コマンド入力移動"],
  "コマンド入力後"  => ["座標リセット早"],
  "コマンド後防御"  => ["座標リセット早","ループ開始","待機固定WT","ループ終了"],
  "コマンド後魔法"  => ["座標リセット早","待機固定","ループ開始","魔法詠唱中","ループ終了"],
  "コマンド後特技"  => ["座標リセット早","待機固定","ループ開始","特技待機中","ループ終了"],
  "防御"          => ["対象アニメ","待機固定WT"],
  "回避"          => ["アクター限定","右1回転","一歩後ジャンプ","10","座標リセット左向き"],
  "盾ガード"       => ["se('Evasion2')","盾防御","60"],
  "勝利ポーズ振り"  => ["勝利ジャンプ武器","勝利ジャンプ着地","120"],
  "勝利ポーズ拳" => ["右1回転","勝利ジャンプ","武器拳突き","120"],
  "勝利ポーズバク転"=> ["右1回転","勝利ジャンプ","武器振りR","120"],

  # ―リアクション系―
  "被ダメージ"    => ["ダメージのけぞり","座標リセット左向き"],
  "被ダメージ大" => ["ダメージのけぞり大","座標リセット左向き"],
  "縦揺れ"       => ["縦揺れ01","縦揺れ02","縦揺れ01","縦揺れ02","縦揺れ01","縦揺れ02"],

  # ―ショートカット系(他のフルアクションから呼び出されるパーツ)―
  "通常攻撃始め" => ["敵前移動","コラプス禁止","個別開始","二刀流限定","二刀左"],
  "通常攻撃終わり"  => ["対象アニメ武器WT","個別終了","コラプス禁止解除","座標リセットカーブ"],
  "二刀左"       => ["武器振りL","対象アニメ武器LWT"],
  "特技発動"       => ["一歩前移動","武器掲げ","特技発動アニメ"],
  "魔法発動"       => ["一歩前移動","武器掲げ","魔法発動アニメ"],
  "カットイン"    => ["カットイン背景始","カットイン分岐","70","カットイン終","カットイン背景終","20"],
  "カットイン分岐"  => ["アクターID1限定","カットインA1","アクターID2限定","カットインA2","アクターID6限定","カットインA3","アクターID7限定","カットインA4"],
  "死亡フラグ動画"  => ["白フェードイン","50","死亡フラグムービー","白フェードアウト","50"],

  # ――通常攻撃系――
  "通常攻撃"       => ["通常攻撃始め","待機固定","通常攻撃終わり"],
  "斬り攻撃"       => ["通常攻撃始め","武器振りR","通常攻撃終わり"],
  "拳攻撃"       => ["通常攻撃始め","武器拳突き","通常攻撃終わり"],
  "突き攻撃"       => ["通常攻撃始め","武器突き","通常攻撃終わり"],
  "弓攻撃"       => ["一歩前移動","コラプス禁止","個別開始","Bow1","弓撃ち",
                     "矢発射","個別終了","コラプス禁止解除","座標リセット"],

  # ――スキル系―――
  "汎用スキル"    => ["特技発動","武器振りR","対象アニメWT","座標リセット"],
  "汎用魔法"       => ["魔法発動","武器振りR","対象アニメWT","座標リセット"],

  "水鉄砲"       => ["特技発動","武器振りR","水鉄砲発射","座標リセット"],
  "武器投げ"       => ["特技発動","Bow1","武器振りR","6","待機固定","武器投げ開始","武器投げ戻し","座標リセット"],
  "雷球"          => ["特技発動","武器振りR","雷発射","座標リセット"],
  "カットイン攻撃"  => ["特技発動","カットイン","通常攻撃始め","武器振りR","通常攻撃終わり"],
  "ムービー攻撃" => ["特技発動","待機固定","死亡フラグ動画","通常攻撃始め","武器振りR","通常攻撃終わり"],
  "オオカミ変身" => ["特技発動","待機固定","オオカミに変身","スキル発動","40","座標リセット"],
  "5回攻撃"       => ["特技発動","敵前移動","武器振りR","対象アニメ武器","15","武器振りR","対象アニメ武器","15","武器振りR","対象アニメ武器","15","武器振りR","対象アニメ武器","15","武器振りR","対象アニメ武器","15","座標リセット"],
  "スキル派生"    => ["武器投げ","多段攻撃に派生"],
  "空中攻撃"       => ["特技発動","Bow1","一歩前ジャンプ",
                     "叩き付け前ジャンプ","待機固定","左1回転","6",
                     "anime(117,false)","叩き付け","対象アニメ","シェイク中",
                     "強制","縦揺れ","20","一歩後ジャンプ","座標リセット"],

  # ――アイテム系―――
  "アイテム使用"    => ["敵前移動","待機固定","対象アニメWT","座標リセット左向き"],


  }



#==============================================================================
# ■ バトルプログラム
#------------------------------------------------------------------------------
# 　バトルシーンの演出を時間管理します
# 　制御はゲームスイッチ・サイドビュー専用スイッチで行います
#==============================================================================
  BATTLE_PROGRAM = {

#--------------------------------------------------------------------------
# ● スイッチの制御  スイッチの時間操作で、演出をプログラムします
#--------------------------------------------------------------------------
  # ｽｲｯﾁ…ﾌﾟﾛｸﾞﾗﾑ実行合図となるｹﾞｰﾑｽｲｯﾁ番号。ﾏｲﾅｽでｻｲﾄﾞﾋﾞｭｰ専用ｽｲｯﾁ番号になります
  #    OFFにすると、実行中のﾌﾟﾛｸﾞﾗﾑは中止されます
  #    ｻｲﾄﾞﾋﾞｭｰ専用ｽｲｯﾁは戦闘終了時に初期化(全てOFFに)されます
  #    イベントで戦闘前にｻｲﾄﾞﾋﾞｭｰ専用ｽｲｯﾁを操作する場合、イベントスクリプトで
  #    $sv_camera.switches[1] = true と入れてください
  #    (1は操作するｽｲｯﾁ番号、ONにするならtrue OFFにするならfalse)
  #
  # ON番号…ONにするするｹﾞｰﾑｽｲｯﾁ番号。ﾏｲﾅｽでｻｲﾄﾞﾋﾞｭｰ専用ｽｲｯﾁ番号になります
  #       番号は一括して配列に入れます。
  #       例…[1,2,-5] ｹﾞｰﾑｽｲｯﾁ1番2番とｻｲﾄﾞﾋﾞｭｰ専用ｽｲｯﾁ5番がON
  #
  # OFF番号…OFFにするするｹﾞｰﾑｽｲｯﾁ番号。ﾏｲﾅｽでｻｲﾄﾞﾋﾞｭｰ専用ｽｲｯﾁ番号になります
  #       操作しない場合は[]と入れます
  #
  # 時間…上のスイッチ操作を実行するまでの時間(単位は1フレーム)
  #    例えば100とした場合、ﾌﾟﾛｸﾞﾗﾑ開始から100ﾌﾚｰﾑ後にｽｲｯﾁ操作が実行されます
  #    [参考値] 30秒…1800　1分…3600　5分…18000 10分…36000　1時間…216000
  #
  # ﾗﾝﾀﾞﾑ幅…時間に加算されるランダム幅。単位は1フレーム
  #       例えば時間300、ﾗﾝﾀﾞﾑ幅300だと最終的に300～600フレームの時間になります

  #――ﾌﾟﾛｸﾞﾗﾑ名――    判別ｽｲｯﾁ ON番号  OFF番号時間  ﾗﾝﾀﾞﾑ幅
  "背景を砦に"    => ["switch",  -1, [-2],    [], 1800,    0],
  "背景を海に"    => ["switch",  -2, [-3],    [], 1800,    0],

#--------------------------------------------------------------------------
# ● SE/BGM/BGSの演奏
#--------------------------------------------------------------------------
  # ｽｲｯﾁ…実行合図となるｹﾞｰﾑｽｲｯﾁ番号。ﾏｲﾅｽはｻｲﾄﾞﾋﾞｭｰ専用ｽｲｯﾁ。
  #
  # 種別…SEの操作なら"se"  BGMの操作なら"bgm"  BGSの操作なら"bgs"
  #
  # ﾋﾟｯﾁ…ピッチ。50～150まで指定できます。100がデフォルトです
  # 音量…ボリューム。50～150まで指定できます。100がデフォルトです
  # ﾌｧｲﾙ名…再生するファイル名。""にするとBGM、BGSを変えずに各種設定可能。

  #――ﾌﾟﾛｸﾞﾗﾑ名――    判別ｽｲｯﾁ  種別  ﾋﾟｯﾁ  音量  ﾌｧｲﾙ名
  "潮騒"          => ["sound",  -1, "bgs",  100,  80, "Sea"],

#--------------------------------------------------------------------------
# ● 背景の制御  画像変更や自動スクロールを行います
#--------------------------------------------------------------------------
  # ｽｲｯﾁ…実行合図となるｽｲｯﾁ番号
  #
  # No.…操作する背景のナンバー。1が床背景、2が壁背景(遠景)になります
  #
  # ｽｸﾛｰﾙ速度…背景の移動する速度。[X軸, Y軸]
  #          単位は100フレームあたりに移動するピクセル数になります
  #          高速で移動させる場合は、1000単位の数値が目安です
  #
  # BA反転…バックアタック時に背景のX座標スクロールを逆にするならtrue 画像は反転しません
  #
  # 画像…背景画像を変更する場合、ﾌｧｲﾙ名を入れます。変更しない場合は""
  #    床背景はBattlebacks1フォルダ、壁背景はBattlebacks2フォルダから参照します
  #    変更する背景設定は、変更前のものを引き継ぎます
  #
  # 繋ぎ画像…背景ｽｸﾛｰﾙ時、背景変更を自然に見せるための繋ぎ画像ﾌｧｲﾙ名
  #          ｽｸﾛｰﾙ途中で背景変更が行われた場合、ｽｸﾛｰﾙが終わってから変更が行われます
  #          性質上、斜めスクロールには対応していません
  #

  #――ﾌﾟﾛｸﾞﾗﾑ名――    判別ｽｲｯﾁ No. ｽｸﾛｰﾙ速度 BA反転画像    繋ぎ画像
  "遠景右移動"    => ["scroll", -1,  1, [  35, 0],  true,  "",       ""],
  "海背景3に変更" => ["scroll", -2,  1, [ 120, 0],  true,  "Sea_ex03", "Sea_ex02"],
  "海背景4に変更" => ["scroll", -3,  1, [  35, 0],  true,  "Sea_ex01", "Sea_ex04"],

#--------------------------------------------------------------------------
# ● 周期ピクチャ　周期的にタイル状のピクチャを操作します。風や巨大魔方陣などに
#--------------------------------------------------------------------------
  # ｽｲｯﾁ…実行合図となるｹﾞｰﾑｽｲｯﾁ番号
  # No.…操作するﾋﾟｸﾁｬの番号。ﾋﾟｸﾁｬは何枚も表示できます
  # 移動速度…100フレームあたりに移動するﾋﾟｸﾁｬの速度。[X軸, Y軸] 0で背景ｽｸﾛｰﾙと同期化
  # 期間…このプログラムを行う期間。単位は1フレーム。0にすると時間無制限でループ
  #
  # 透明操作…ﾋﾟｸﾁｬの透明度操作。[開始透明度, 100ﾌﾚｰﾑあたりに加算する透明度]
  #          透明度が255になると開始透明度まで戻り、それを繰り返します
  # Z軸…ﾋﾟｸﾁｬのZ座標。100以上にするとウインドウより手前に表示されます
  # ｼｪｲｸ許可…シェイクアクションの揺れと連動するならtrue
  # BA反転…バックアタック時にピクチャのX座標移動を逆にするならtrue 画像は反転しません
  # ﾌｧｲﾙ名…ﾋﾟｸﾁｬのﾌｧｲﾙ名。Picturesフォルダを参照します

  #――ﾌﾟﾛｸﾞﾗﾑ名――  判別ｽｲｯﾁ  No. 移動速度期間透明操作 Z軸  ｼｪｲｸ許可 BA反転ﾌｧｲﾙ名
  "風"          => ["kpic", -1,  0, [  500, 0], 0, [ 255, 0],  90, false,  true, "back_wind"],

#--------------------------------------------------------------------------
# ● 周期SE　周期的に効果音を鳴らします。雷鳴や潮騒などに
#--------------------------------------------------------------------------
  # ｽｲｯﾁ…実行合図となるｹﾞｰﾑｽｲｯﾁ番号
  # 周期…効果音を鳴らす周期。単位は1フレーム。この間隔で効果音が定期的に鳴ります
  # ﾗﾝﾀﾞﾑ幅…周期に加算されるランダム幅。単位は1フレーム
  #
  # ﾋﾟｯﾁ…ピッチ。50～150まで指定できます。100がデフォルトです
  # 音量…ボリューム。50～150まで指定できます。100がデフォルトです
  # 開始実行…ﾌﾟﾛｸﾞﾗﾑ実行直後に周期を待たず鳴らすならtrue
  # ﾌｧｲﾙ名…再生するファイル名。

  #――ﾌﾟﾛｸﾞﾗﾑ名――    判別ｽｲｯﾁ周期  ﾗﾝﾀﾞﾑ幅  ﾋﾟｯﾁ音量開始実行ﾌｧｲﾙ名
  "カモメ"       => ["keep_se", -1,  300, 100,  150,  60,  false,  "Crow"],
  "カモメ2"       => ["keep_se", -1,  200, 200,  140,  45, true,  "Crow"],

#--------------------------------------------------------------------------
# ● 周期シェイク　周期的に画面を揺らします
#--------------------------------------------------------------------------
  # ｽｲｯﾁ…実行合図となるｹﾞｰﾑｽｲｯﾁ番号。これがONになることで開始されます
  # 周期…画面を揺らす周期。単位は1フレーム
  # ﾗﾝﾀﾞﾑ幅…周期に加算されるランダム幅。単位は1フレーム
  #
  # 方向…揺れる方向 [横,縦] 数値が大きいほど揺れも大きくなります
  # 速度…揺れの速度。小さいほど早く揺れます
  # 時間…揺れの続く時間。揺れ幅は時間と共に少しずつ弱まっていきます
  # 開始実行…ﾌﾟﾛｸﾞﾗﾑ実行直後に周期を待たず揺らすならtrue

  #――ﾌﾟﾛｸﾞﾗﾑ名――    判別ｽｲｯﾁ周期ﾗﾝﾀﾞﾑ幅方向速度  時間開始実行
  "船の揺れ"    => ["keep_sk", -1,  130, 0,  [  0, 4], 80,  120,  true],

#--------------------------------------------------------------------------
# ● 周期色調変更　周期的に画面の色調を変更します
#--------------------------------------------------------------------------
  # ｽｲｯﾁ…実行合図となるｹﾞｰﾑｽｲｯﾁ番号。これがONになることで開始されます
  # 周期…色調変更させる周期。単位は1フレーム
  # ﾗﾝﾀﾞﾑ幅…周期に加算されるランダム幅。単位は1フレーム
  #
  # 対象…色調変更の対象 [0=背景] [1=敵全] [2=味方全] [3=敵味方全] [4=全て]
  # 色調レベル…[ R, G, B, ｱﾙﾌｧ(色の強さ), 変更時間, ※戻り]
  #          ※戻り…変更完了してから元の色に戻す時間。戻さないなら0
  # 開始実行…ﾌﾟﾛｸﾞﾗﾑ実行直後に周期を待たず色調変更するならtrue

  #――ﾌﾟﾛｸﾞﾗﾑ名――    判別ｽｲｯﾁ周期ﾗﾝﾀﾞﾑ幅  対象    R, G, B, ｱﾙﾌｧ  時間戻り  開始実行
  "雷光"          => ["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バトラー設定
#------------------------------------------------------------------------------
# 　アクション設定で作ったアクションをバトラーに貼り付けたり
# 　バトラーに関する設定を行います
#==============================================================================
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
  #--------------------------------------------------------------------------
  # ● バトラー画像反転設定　初期状態でバトラー画像を反転させるならtrue
  #--------------------------------------------------------------------------
  def graphic_mirror_flug
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 first_action
return "戦闘開始味方" if id > 0 # 全アクター
return "待機固定WT" if id < 0 # 全エネミー
  end
  #--------------------------------------------------------------------------
  # ● 勝利アクション
  #--------------------------------------------------------------------------
  def win
case id
when  2 # 2番のアクター
   return "勝利ポーズ拳"
when  7,10 # 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
# 選択したスキルIDで分岐
case skill_id
when 2
   return "コマンド後防御"
end
# 選択したスキルタイプで指定
case skill_type
when 1 # 特技
   return "コマンド後特技"
when 2 # 魔法
   return "コマンド後魔法"
end
# 上の指定以外
return "コマンド入力後"
  end
  #--------------------------------------------------------------------------
  # ● 被ダメージアクション　
  #--------------------------------------------------------------------------
  def damage(attacker)
# 受けた攻撃がクリティカルの場合
if critical?
   return "被ダメージ大"
# 回復の場合
elsif recovery?
   return
   # アクションを取らせたくない時はreturnのみを記述します
end
# 受けたスキルIDで分岐
case damage_skill_id
when 1 # スキル1番の場合
   return "被ダメージ"
when 2,6,135 # 防御、エネミーの逃走はダメージアクションなし
   return
   # 特定のスキルにダメージアクションを取らせたくない時はここでreturnのみを記述します
end
# 受けたアイテムIDで指定(回復の場合は既にアクションが決定されています)
case damage_item_id
when 1 # アイテム1番の場合
   return
else
   # 上のアイテムID以外
   if damage_item_id != 0
      return
   end
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 0 # 武器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
case skill_id # スキルIDで指定
when 1 # スキル1番は通常攻撃なので、上の武器アクションを実行します
   return weapon_action
when 2 # スキル2番は防御
   return "防御"
when 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 "空中攻撃"
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

end

各位大大帮帮忙啊
作者: 月满月西楼 时间: 2012-12-3 22:41
横版战斗这个脚本，要求的怪物图画和人物图画不一样
要用这个脚本的话，怪物和人物的图画必须是一排四连类似行走图一样的图片才行。
作者: wuyueyu 时间: 2012-12-3 23:35

月满月西楼发表于 2012-12-3 22:41
横版战斗这个脚本，要求的怪物图画和人物图画不一样
要用这个脚本的话，怪物和人物的图画必须是一排四连类 ...

感谢你的回答= =不过我已经解决啦啦啦

欢迎光临 Project1 (https://rpg.blue/) Powered by Discuz! X3.1