Страница 85 из 143 ПерваяПервая ... 3575838485868795135 ... ПоследняяПоследняя
Показано с 841 по 850 из 1426

Тема: Помощь с скриптами (RGSS)

  1. #841
    Местный Аватар для SethNsk
    Информация о пользователе
    Регистрация
    25.03.2010
    Сообщений
    235
    Записей в дневнике
    7
    Репутация: 12 Добавить или отнять репутацию

    По умолчанию

    Подскажите, как использовать данный скрипт?
    Спойлер скрипт:
    PHP код:
    # 9Sun - Event Spawner Fix
    #
    # Please note that the spawn_event function doesn't belong to me. I forget where I found it. Contact me if you created
    # this snippet so that I can put your name as credit.
    #
    # Event Spawner
    #   _map_id:   ID of the map where the events resides
    #   _event_id: The Event ID
    #   _x:        X Coordinate the put the new event
    #   _y:        Y Coordinate the put the new event
    #
    #   Returns: New Event ID
    #

    # Some fixes done on this function (I didn't wrote the original piece).

    def spawn_event(_map_id_event_id_x_y)
      
    map              load_data(sprintf("Data/Map%03d.rvdata2"_map_id))
      
    event_id         $game_map.events.keys.max 1
      event            
    $game_map.events[event_id] = Game_Event.new($game_map.map_idmap.events[_event_id],event_id)
      
    event.moveto(_x_y)
      
    sp_map           SceneManager.scene.instance_eval('@spriteset')
      
    sp_map_char_sprs sp_map.instance_eval('@character_sprites')
      
    sp_map_view_1    sp_map.instance_eval('@viewport1')
      
    sp_map_char_sprs.push(Sprite_Character.new(sp_map_view_1event))
      
    event_id
    end

    # Following are the fix written by me. It overwrites alot of methods in Game_Event class so check yourself for compatibility issues.

    class Game_Event Game_Character
      def initialize
    (map_ideventreal_id false)
        
    super()
        @
    map_id map_id
        
    @event event
        
    @real_id real_id real_id : @event.id
        
    @id = @real_id
        moveto
    (@event.x, @event.y)
        
    refresh
      end

      def conditions_met
    ?(page)
        
    page.condition
        
    if c.switch1_valid
          
    return false unless $game_switches[c.switch1_id]
        
    end
        
    if c.switch2_valid
          
    return false unless $game_switches[c.switch2_id]
        
    end
        
    if c.variable_valid
          
    return false if $game_variables[c.variable_id] < c.variable_value
        end
        
    if c.self_switch_valid
          key 
    = [@map_id, @real_idc.self_switch_ch]
          return 
    false if $game_self_switches[key] != true
        end
        
    if c.item_valid
          item 
    $data_items[c.item_id]
          return 
    false unless $game_party.has_item?(item)
        
    end
        
    if c.actor_valid
          actor 
    $game_actors[c.actor_id]
          return 
    false unless $game_party.members.include?(actor)
        
    end
        
    return true
      end

      alias sun_event_spawn_erase erase

      def erase
        
    if @event.id != @real_id
          
    ['A','B','C','D'].each{|ch|
            
    key = [@map_id, @real_idch]
            
    $game_self_switches[key] = false
            
    }
        
    end
        sun_event_spawn_erase
      end

      def update
        super
        check_event_trigger_auto
        
    return unless @interpreter
        
    @interpreter.setup(@list, @real_idunless @interpreter.running?
        @
    interpreter.update
      end
    end 

  2. #842

    По умолчанию

    Версия мейкера VX Ace

    Спойлер 1:
    #================================================= =============================
    # ■ Sideview Ver100
    #------------------------------------------------------------------------------
    #  サイドビューバトラーを管理する ラスです。
    #================================================= =============================
    class SideView
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数 
    #--------------------------------------------------------------------------
    attr_accessor :x # 画面X座標
    attr_accessor :y # 画面Y座標
    attr_accessor :z # 画面Z座標
    attr_accessor :h # 高さ座標
    attr_accessor :j # ジャンプ座標
    attr_accessor :c # カーブ座標
    attr_accessor x # 横原点
    attr_accessor y # 縦原点
    attr_accessor y_adjust # 縦原点補正
    attr_accessor :angle # 回転角度
    attr_accessor :zoom_x # 横の拡大率
    attr_accessor :zoom_y # 縦の拡大率
    attr_accessor attern_w # セル横位置(矩形内)
    attr_accessor attern_h # セル縦位置(矩形内)
    attr_accessor :sx # セル横位置(画像全体)
    attr_accessor :sy # セル縦位置(画像全体)
    attr_accessor attern_type # セル更新タイプ
    attr_accessor attern_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 pacity # 透明度
    attr_accessor pacity_data # 透明度操作情報
    attr_accessor :set_damage # バトルシーンでのダメージ処理
    attr_accessor :m_a_data # アニメ飛ばし情報
    attr_accessor :m_a_starter # アニメ飛ばし開始ターゲット情報
    attr_accessor :action_end # バトルシーンでの行動終了
    attr_accessor :damage_anime_data # ダメージ戦闘アニメのデータ
    attr_accessor :anime_no_mirror # 戦闘アニメの反転禁止フラグ
    attr_accessor :anime_horming # 戦闘アニメのホーミングフラグ
    attr_accessor :anime_camera_zoom # 戦闘アニメがカメラに合わせて拡大 小するか
    attr_accessor :anime_plus_z # 戦闘アニメZ座標補正
    attr_accessor :derivation_skill_id # スキル派生ID
    attr_accessor :immortal # 不死身フラグ
    attr_accessor :mirage # 残像データ
    attr_accessor :balloon_data # ふきだしデータ
    attr_accessor :timing # 別バトラーからのタイミングデータ
    attr_accessor :timing_targets # タイミングデータを渡す別バトラー
    attr_accessor :color_set # 色調変更データ
    attr_accessor :color # 色調データ
    attr_accessor :change_up # 画像変更フラグ
    attr_accessor :hit # 被攻撃回数
    attr_accessor :add_state # 何度も付加ステートの表示を防ぐフ グ
    attr_accessor :counter_id # カウンター時のスキルID
    attr_accessor :reflection_id # 魔法反射時のアニメID
    attr_accessor :result_damage # ターン終了時のHP変動データ
    attr_accessor :active # 行動権
    attr_accessor :anime_off # 戦闘アニメ消去
    attr_accessor :command_action # コマンドアクションフラグ

    attr_accessor :base_x # 初期位置 X座標
    attr_accessor :base_y # 初期位置 Y座標
    attr_accessor :base_h # 初期位置 高さ座標
    attr_accessor :max_pattern_w # セルの横分割数
    attr_accessor :max_pattern_h # セルの縦分割数

    attr_reader :collapse # コラプスフラグ
    attr_reader icture # ピクチャ表示フラグ
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    def initialize(battler)
    @battler = battler
    reset
    end
    #--------------------------------------------------------------------------
    # ● 初期化
    #--------------------------------------------------------------------------
    def reset
    @x = 0
    @y = 0
    @z = 0
    @h = 0
    @j = 0
    @c = 0
    @jump = []
    @curve = []
    @ox = 0
    @oy = 0
    @oy_adjust = 0
    @z_plus = 0
    @move_time = 0
    @angle = 0
    @angle_time = 0
    @zoom_x = 1
    @zoom_y = 1
    @zoom_time = 0
    @pattern_w = 0
    @pattern_h = 0
    @sx = 0
    @sy = 0
    @pattern_type = 0
    @pattern_time = 0
    @pattern_rest_time = 0
    @graphic_name = ""
    @graphic_file_index = ""
    @graphic_index = 0
    @cw = 0
    @ch = 0
    @shadow_visible = false
    @weapon_visible = true

    @wait = 0
    @weapon_index = []
    @weapon_end = true
    @full_action = []
    @action = []
    @force_action = ""
    @target_battler = []
    @second_targets = []
    @individual_targets = []
    @m_a_targets = []
    @effect_data = []
    @anime_id = []
    @anime_move_id = []
    @opacity = 255
    @opacity_data = []
    @set_damage = false
    @m_a_data = []
    @m_a_starter = []
    @action_end = false
    @damage_anime_data = []
    @anime_no_mirror = false
    @anime_horming = false
    @anime_camera_zoom = false
    @anime_plus_z = true
    @derivation_skill_id = 0
    @immortal = false
    @mirage = []
    @play_data = []
    @balloon_data = []
    @picture = false
    @timing = []
    @timing_targets = []
    @color_set = []
    @color = []
    @change_up = false
    @non_motion = false
    @graphics_change = false
    @hit = []
    @add_state = []
    @collapse = false
    @counter_id = 0
    @reflection_id = 0
    @result_damage = [0,0]
    @active = false
    @anime_off = false
    @command_action = false

    @base_x = 0
    @base_y = 0
    @base_z = 0
    @base_h = 0
    @max_pattern_w = 0
    @max_pattern_h = 0
    @pattern_kind = 0
    @pattern_count = 0
    @move_time = 0
    @mirror = false
    @battler.set_graphic(@pre_change_data[0], @pre_change_data[1], @pre_change_data[2], @pre_change_data[3]) if @pre_change_data != nil
    @pre_change_data = nil
    end
    #--------------------------------------------------------------------------
    # ● セットアップ
    #--------------------------------------------------------------------------
    def setup(bitmap_width, bitmap_height, first_action_flag)
    reset if first_action_flag
    set_data
    set_base_position if !@graphics_change
    set_graphics(bitmap_width, bitmap_height)
    set_target
    setup_graphics_change if @graphics_change
    first_battler_anime_set if first_action_flag
    end
    #--------------------------------------------------------------------------
    # ● バトラーデータ取得
    #--------------------------------------------------------------------------
    def set_data
    return if @battler == nil
    if @battler.actor?
    @graphic_name = @battler.character_name
    @graphic_index = @battler.character_index
    else
    @graphic_name = @battler.battler_name
    @graphic_index = 0
    end
    @max_pattern_w = max_pattern[0]
    @max_pattern_h = max_pattern[1]
    end
    #--------------------------------------------------------------------------
    # ● ベース座標をセット data = [X軸, Y軸, H軸] moment_set…瞬間配置
    #--------------------------------------------------------------------------
    def set_base_position(moment_set = true)
    mirroring_reset
    if @battler.actor?
    data = N03::ACTOR_POSITION[@battler.index].dup
    @base_x = data[0] * 100 if !@mirror
    @base_x = (Graphics.width - data[0]) * 100 if @mirror
    else
    data = [@battler.screen_x, @battler.screen_y, 0].dup
    @base_x = data[0] * 100 if !$sv_camera.mirror
    @base_x = (Graphics.width - data[0]) * 100 if $sv_camera.mirror
    end
    @base_y = data[1] * 100
    @base_h = data[2] * 100
    @base_z = @y
    return if !moment_set
    @x = @base_x
    @y = @base_y
    @z = @base_z
    end
    #--------------------------------------------------------------------------
    # ● グラフィックデータ取得
    #--------------------------------------------------------------------------
    def set_graphics(bitmap_width, bitmap_height)
    sign = @graphic_name[/^[\!\$]./]
    if sign && sign.include?('$')
    @cw = bitmap_width / @max_pattern_w
    @ch = bitmap_height / @max_pattern_h
    elsif @max_pattern_w == 1 && @max_pattern_h == 1
    @cw = bitmap_width
    @ch = bitmap_height
    else
    @cw = bitmap_width / (@max_pattern_w * 4)
    @ch = bitmap_height / (@max_pattern_h * 2)
    end
    @ox = @cw / 2
    @oy = @ch
    @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
    @sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch
    end
    #--------------------------------------------------------------------------
    # ● ターゲットをセット
    #--------------------------------------------------------------------------
    def set_target(target = nil)
    @target_battler = target
    @target_battler = [@battler] if target == nil
    @second_targets = @target_battler
    end
    #--------------------------------------------------------------------------
    # ● 画像変更用のセットアップ
    #--------------------------------------------------------------------------
    def setup_graphics_change
    @graphics_change = false
    @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
    @sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch
    end
    #--------------------------------------------------------------------------
    # ● 戦闘開始時の待機アニメ画像データ 得
    #--------------------------------------------------------------------------
    def first_battler_anime_set
    loop do
    update
    break if @action_data == nil
    break if @action_data[0] == "motion"
    break if @action_data[0] == "move" && @action_data[8] != ""
    break if @full_action == []
    end
    start_action(first_action) if @battler.movable?
    end
    #--------------------------------------------------------------------------
    # ● アクション開始
    #--------------------------------------------------------------------------
    def start_action(kind = nil)
    return if @event_fix && $game_troop.interpreter.running?
    # ウェイト中の場合キャンセル
    return @wait -= 1 if @wait > 0 && kind == nil
    action_setup(false) if kind != nil
    set_action(kind)
    @action = kind if @action == nil
    # 行動配列が無い場合は行動終了処理 移行
    action_terminate if @action == nil
    # 次のアクション決定
    @action_data = N03::ACTION[@action]
    next_action
    end
    #--------------------------------------------------------------------------
    # ● 行動パラメータの初期化
    #--------------------------------------------------------------------------
    def action_setup(reset = true)
    @event_fix = false
    @set_damage = false
    @action_end = false
    @balloon_data = []
    @loop_act = []
    angle_reset if reset
    zoom_reset if reset
    opacity_reset if reset
    @curve = []
    @c = 0
    convert_jump
    end
    #--------------------------------------------------------------------------
    # ● 行動終了処理
    #--------------------------------------------------------------------------
    def action_terminate
    @mirage = [] if @mirage_end
    mirroring_reset
    @picture = false
    @individual_targets = []
    action_setup if @active
    action_setup(false) if !@active
    # 待機アクションへ移行
    stand_by_action if !@non_motion
    # 戦闘行動のアクティブ権を終了
    next_battler
    end
    #--------------------------------------------------------------------------
    # ● 新しいアクション内容の決定
    #--------------------------------------------------------------------------
    def set_action(kind = nil)
    full_act = N03::FULLACTION[kind]
    @full_action = full_act.dup if full_act != nil
    @action = @full_action.shift
    # 参照したアクションがフルアクショ であれば全体のアクションを統合
    full_act2 = N03::FULLACTION[@action]
    @full_action = full_act2.dup + @full_action if full_act2 != nil
    end
    #--------------------------------------------------------------------------
    # ● 次のアクションへ
    #--------------------------------------------------------------------------
    def next_action
    @wait = 0
    # ショートカット確認
    eval(@action) if @action != nil && @action_data == nil && N03::FULLACTION[@action] == nil
    # ウエイト設定
    @wait = @action.to_i if @wait == 0 && @action_data == nil
    @wait = rand(@wait.abs + 1) if @wait < 0
    # アクション開始
    action_play
    end
    #--------------------------------------------------------------------------
    # ● 待機アクションへ移行
    #--------------------------------------------------------------------------
    def stand_by_action
    # 通常待機に
    stand_by_act = normal
    # HPが1/4でピンチアクションに
    stand_by_act = pinch if @battler.hp <= @battler.mhp / 4
    # ステートチェック
    stand_by_act = state(@battler.states[0].id) if @battler.states[0] != nil && state(@battler.states[0].id) != nil
    # コマンドチェック
    stand_by_act = command if @command_action && command != nil
    set_action(stand_by_act)
    @action = stand_by_act if @action == nil
    end
    #--------------------------------------------------------------------------
    # ● 強制アクション開始
    #--------------------------------------------------------------------------
    def start_force_action
    return if @active
    start_action(@force_action)
    @force_action = ""
    end
    #--------------------------------------------------------------------------
    # ● アクション追加
    #--------------------------------------------------------------------------
    def add_action(kind)
    @full_action.push(kind)
    end
    #--------------------------------------------------------------------------
    # ● アクションの挿入
    #--------------------------------------------------------------------------
    def unshift_action(kind)
    @full_action.unshift(kind)
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def update
    # アクション開始
    start_action
    # 強制アクション開始
    start_force_action if @force_action != ""
    # アニメパターン更新
    update_pattern
    # 移動更新
    update_move
    # 回転更新
    update_angle if @angle_time != 0
    # 拡大縮小更新
    update_zoom if @zoom_time != 0
    # 透明度更新
    update_opacity if @opacity_data != []
    end
    #--------------------------------------------------------------------------
    # ● アニメパターン更新
    #--------------------------------------------------------------------------
    def update_pattern
    return @pattern_rest_time -= 1 if @pattern_rest_time != 0
    return if @max_pattern_w == 1 && @max_pattern_h == 1
    @pattern_rest_time = @pattern_time
    # 再生開始・終了セル位置を取得
    if @pattern_kind > 0 # 通常再生中
    @pattern_start = 0
    @pattern_end = @max_pattern_w - 1
    elsif @pattern_kind < 0 # 逆転再生中
    @pattern_start = @max_pattern_w - 1
    @pattern_end = 0
    end
    # 片道の再生が終了
    @pattern_count += 1 if @pattern_w == @pattern_end && @pattern_kind != 0
    # ループ処理
    case @pattern_type.abs
    when 1,3 # 片道
    @pattern_kind = 0 if @pattern_count != 0 && @pattern_type == 1
    @pattern_kind = 0 if @pattern_count != 0 && @pattern_type == -1
    @pattern_kind = 1 if @pattern_count != 0 && @pattern_type == 3
    @pattern_kind = -1 if @pattern_count != 0 && @pattern_type == -3
    @pattern_w = @pattern_start - @pattern_kind if @pattern_count != 0 && @pattern_type.abs == 3
    @pattern_count = 0
    when 2,4 # 往復
    @pattern_kind = -1 if @pattern_count == 1 && @pattern_type == 2
    @pattern_kind = 1 if @pattern_count == 1 && @pattern_type == -2
    @pattern_kind = 0 if @pattern_count == 2 && @pattern_type == 2
    @pattern_kind = 0 if @pattern_count == 2 && @pattern_type == -2
    @pattern_kind = -1 if @pattern_count == 1 && @pattern_type == 4
    @pattern_kind = 1 if @pattern_count == 1 && @pattern_type == -4
    @pattern_kind = 1 if @pattern_count == 2 && @pattern_type == 4
    @pattern_kind = -1 if @pattern_count == 2 && @pattern_type == -4
    @pattern_count = 0 if @pattern_count == 2
    end
    # セル更新
    @pattern_w += 1 * @pattern_kind
    @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
    end
    #--------------------------------------------------------------------------
    # ● 移動の更新
    #--------------------------------------------------------------------------
    def update_move
    @z = @y / 100 + @z_plus
    return if @move_time == 0
    target_position_set if @horming_move
    @x = (@x * (@move_time - 1) + @target_x) / @move_time
    @y = (@y * (@move_time - 1) + @target_y) / @move_time
    @h = (@h * (@move_time - 1) + @target_h) / @move_time if @move_h != nil
    @c += @curve[@move_time - 1] if @curve[@move_time - 1] != nil
    @j += @jump[@move_time - 1] if @jump[@move_time - 1] != nil
    @move_time -= 1
    convert_jump if @move_time == 0
    end
    #--------------------------------------------------------------------------
    # ● 移動目標の更新
    #--------------------------------------------------------------------------
    def target_position_set
    target_position = N03.get_targets_position(@move_targets, @horming_move)
    @target_x = target_position[0] + @move_x
    @target_y = target_position[1] + @move_y
    @target_h = target_position[2] + @move_h if @move_h != nil
    end
    #--------------------------------------------------------------------------
    # ● 回転更新
    #--------------------------------------------------------------------------
    def update_angle
    @angle += @angling
    @angle_time -= 1
    return if @angle_time != 0
    return angle_reset if @angle_data[4] == 0
    angling(@angle_data) if @angle_data[4] == 2
    end
    #--------------------------------------------------------------------------
    # ● 拡大縮小更新
    #--------------------------------------------------------------------------
    def update_zoom
    @zoom_x += @zooming_x
    @zoom_y += @zooming_y
    @zoom_time -= 1
    return if @zoom_time != 0
    return zoom_reset if @zoom_data[4] == 0
    zooming(@zoom_data) if @zoom_data[4] == 2
    end
    #--------------------------------------------------------------------------
    # ● 透明度更新
    #--------------------------------------------------------------------------
    def update_opacity
    @opacity += @opacity_data[2]
    @opacity_data[0] -= 1
    return if @opacity_data[0] != 0
    return if !@opacity_data[5]
    @opacity_data[2] *= -1
    @opacity_data[0] = @opacity_data[1]
    end
    #--------------------------------------------------------------------------
    # ● アクション実行
    #--------------------------------------------------------------------------
    def action_play
    return if @action_data == nil
    action = @action_data[0]
    # バトラー反転の場合
    return mirroring if action == "mirror"
    # 残像の場合
    return mirage_set if action == "mirage"
    # 回転の場合
    return angling if action == "angle"
    # 拡大縮小の場合
    return zooming if action == "zoom"
    # 透明度操作の場合
    return set_opacity if action == "opacity"
    # バトラーアニメの場合
    return battler_anime if action == "motion"
    # 移動の場合
    return move if action == "move"
    # 武器アニメの場合
    return weapon_anime([@action_data]) if action == "wp"
    # アニメ飛ばしの場合
    return move_anime if action == "m_a"
    # 戦闘シーン通信の場合(コラプス)
    return set_play_data if action == "collapse" or action == "no_collapse"
    # データベース戦闘アニメ表示の場合
    return battle_anime if action == "anime"
    # カメラワークの場合
    return camera if action == "camera"
    # 画面のシェイクの場合
    return shake if action == "shake"
    # 画面色調変更の場合
    return color_effect if action == "color"
    # トランジションの場合
    return transition if action == "ts"
    # ふきだしアニメ表示の場合
    return balloon_anime if action == "balloon"
    # ピクチャ表示の場合
    return picture_set if action == "pic"
    # ステート操作の場合
    return state_set if action == "sta"
    # FPS変更の場合
    return fps if action == "fps"
    # バトラー画像変更の場合
    return graphics_change if action == "change"
    # スキル派生の場合
    return derivating_skill if action == "der"
    # BGM/BGS/SE演奏の場合
    return sound if action == "sound"
    # ムービー再生の場合
    return movie if action == "movie"
    # ゲームスイッチ操作の場合
    return switches if action == "switch"
    # ゲーム変数操作の場合
    return variable if action == "variable"
    # 条件分岐(ゲームスイッチ)の場合
    return nece_1 if action == "n_1"
    # 条件分岐(ゲーム変数)の場合
    return nece_2 if action == "n_2"
    # 条件分岐(ステート)の場合
    return nece_3 if action == "n_3"
    # 条件分岐(スキル)の場合
    return nece_4 if action == "n_4"
    # 条件分岐(パラメータ)の場合
    return nece_5 if action == "n_5"
    # 条件分岐(装備)の場合
    return nece_6 if action == "n_6"
    # 条件分岐(スクリプト)の場合
    return nece_7 if action == "n_7"
    # セカンドターゲット操作の場合
    return second_targets_set if action == "s_t"
    # コモンイベント呼び出しの場合
    return call_common_event if action == "common"
    # 戦闘アニメ消去の場合
    return @anime_off = true if action == "anime_off"
    # 強制戦闘終了の場合
    return BattleManager.process_abort if action == "battle_end"
    # 画面固定の場合
    return Graphics.freeze if action == "graphics_freeze"
    # ダメージアニメの場合
    return damage_anime if action == "damage_anime"
    # 武器消去の場合
    return @weapon_visible = false if action == "weapon_off"
    # 武器消去解除の場合
    return @weapon_visible = true if action == "weapon_on"
    # 待機キャンセルの場合
    return @non_motion = true if action == "non_motion"
    # 待機キャンセル解除の場合
    return @non_motion = false if action == "non_motion_cancel"
    # 初期位置変更の場合
    return change_base_position if action == "change_base_position"
    # 初期位置変更解除の場合
    return set_base_position(false) if action == "set_base_position"
    # 強制アクションの場合
    return force_act if action == "force_action"
    # 強制アクションの場合 (セカンドターゲット)
    return force_act2 if action == "force_action2"
    # 個別開始の場合
    return individual_start if action == "individual_start"
    # 個別終了の場合
    return individual_end if action == "individual_end"
    # ループ開始の場合
    return loop_start if action == "loop_start"
    # ループ終了の場合
    return loop_end if action == "loop_end"
    # 自分のみ更新の場合
    return only_action_on if action == "only_action_on"
    # 自分のみ更新解除の場合
    return only_action_off if action == "only_action_off"
    # 次の行動者へ移行の場合
    return next_battler if action == "next_battler"
    # 画像変更フラグの場合
    return set_change if action == "set_change"
    # スクリプト操作の場合
    return eval(@action_data[0])
    end
    #--------------------------------------------------------------------------
    # ● バトラー反転実行
    #--------------------------------------------------------------------------
    def mirroring
    @mirror = !@mirror
    end
    #--------------------------------------------------------------------------
    # ● 反転初期化
    #--------------------------------------------------------------------------
    def mirroring_reset
    @mirror = false
    mirroring if !@battler.actor? && N03::ENEMY_MIRROR
    mirroring if $sv_camera.mirror
    end
    #--------------------------------------------------------------------------
    # ● 残像実行
    #--------------------------------------------------------------------------
    def mirage_set
    @mirage = @action_data.dup
    @mirage_end = @mirage[3]
    @mirage = [] if @mirage[1] == 0
    end
    #--------------------------------------------------------------------------
    # ● 回転実行
    #--------------------------------------------------------------------------
    def angling(data = @action_data)
    @angle_data = data.dup
    @oy = @ch / 2
    @oy_adjust = @ch * 50
    @angle_time = data[1]
    start_angle = data[2] * N03.mirror_num(@mirror)
    end_angle = data[3] * N03.mirror_num(@mirror)
    # 時間が0以下なら即座に最終角度へ
    @angle_time = 1 if @angle_time <= 0
    # 回転時間から1フレームあたりの角度 出す
    @angling = (end_angle - start_angle) / @angle_time
    # 割り切れない余りを初期角度に
    @angle = (end_angle - start_angle) % @angle_time + start_angle
    end
    #--------------------------------------------------------------------------
    # ● 回転初期化
    #--------------------------------------------------------------------------
    def angle_reset
    @oy = @ch
    @angle = @angle_time = @oy_adjust = 0
    end
    #--------------------------------------------------------------------------
    # ● 拡大縮小実行
    #--------------------------------------------------------------------------
    def zooming(data = @action_data)
    @zoom_data = data.dup
    @zoom_time = data[1]
    start_zoom_x = data[2][0]
    start_zoom_y = data[2][1]
    end_zoom_x = data[3][0]
    end_zoom_y = data[3][1]
    # 時間が0以下なら即座に最終サイズへ
    @zoom_time = 1 if @zoom_time <= 0
    # 拡大縮小時間から1フレームあたりの 大縮小率を出す
    @zooming_x = (end_zoom_x - start_zoom_x) / @zoom_time
    @zooming_y = (end_zoom_y - start_zoom_y) / @zoom_time
    # 開始サイズに
    @zoom_x = start_zoom_x
    @zoom_y = start_zoom_y
    end
    #--------------------------------------------------------------------------
    # ● 拡大縮小初期化
    #--------------------------------------------------------------------------
    def zoom_reset
    @zoom_x = @zoom_y = 1
    @zoom_time = 0
    end
    #--------------------------------------------------------------------------
    # ● バトラー透明度操作
    #--------------------------------------------------------------------------
    def set_opacity
    data = @action_data.dup
    @opacity = data[2]
    opacity_move = (data[3] - data[2])/ data[1]
    @opacity_data = [data[1], data[1], opacity_move, data[4], data[5], data[6]]
    @wait = data[1] if data[7]
    @wait *= 2 if data[6] && data[7]
    end
    #--------------------------------------------------------------------------
    # ● 透明度操作初期化
    #--------------------------------------------------------------------------
    def opacity_reset
    @opacity = 255
    @opacity = 0 if @battler.hidden?
    @opacity_data = []
    end
    #--------------------------------------------------------------------------
    # ● バトラーアニメ実行
    #--------------------------------------------------------------------------
    def battler_anime(anime_data = nil)
    anime_data = @action_data.dup if anime_data == nil
    @graphic_file_index = anime_data[1] if !graphic_fix
    @pattern_h = anime_data[2]
    @pattern_w = anime_data[3]
    @pattern_h = 0 if @max_pattern_w == 1
    @pattern_w = 0 if @max_pattern_h == 1
    @pattern_type = anime_data[4]
    @pattern_time = anime_data[5]
    @pattern_rest_time = anime_data[5]
    @pattern_count = 0
    @pattern_kind = 1
    @pattern_kind = -1 if @pattern_type < 0
    @pattern_kind = 0 if @pattern_type == 0
    @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
    @sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch
    @z_plus = anime_data[6]
    @wait = set_anime_wait if anime_data[7]
    @shadow_visible = anime_data[8]
    weapon_anime(anime_data)
    end
    #--------------------------------------------------------------------------
    # ● アニメウエイト計算
    #--------------------------------------------------------------------------
    def set_anime_wait
    if @pattern_type > 0
    pattern_time_a = @max_pattern_w - @pattern_w.abs
    elsif @pattern_type < 0
    pattern_time_a = @pattern_w.abs + 1
    else
    return @pattern_time if @pattern_type == 0
    end
    case @pattern_type
    when 1,-1, 3,-3
    return pattern_time_a * @pattern_time
    when 2,-2, 4,-4
    return pattern_time_a * @pattern_time + (@max_pattern_w - 2) * @pattern_time
    end
    end
    #--------------------------------------------------------------------------
    # ● 移動実行
    #--------------------------------------------------------------------------
    def move
    @move_targets = N03.get_targets(@action_data[1].abs, @battler)
    return if @move_targets == []
    @move_targets = [@battler] if @action_data[1].abs == 7
    @move_x = @action_data[2] * 100 * N03.mirror_num(@mirror)
    @move_y = @action_data[3] * 100
    @move_h = @action_data[4] * 100 if @action_data[4] != nil
    @move_h = nil if @action_data[4] == nil
    battler_anime(N03::ACTION[@action_data[8]].dup) if N03::ACTION[@action_data[8]] != nil
    @horming_move = true
    @horming_move = false if @action_data[1] < 0 or @action_data[1].abs == 7
    target_position_set
    target_position = [@target_x, @target_y, @target_z]
    distanse_move = @action_data[5] > 0
    @move_time = N03.distanse_calculation(@action_data[5].abs, target_position, [@x, @y, @z], distanse_move)
    @wait = @move_time
    curve
    jump
    @move_time = 1 if @move_time == 0
    @horming_move = false if !@move_targets or @move_targets.include?(@battler)
    update_move if @move_time == 1
    end
    #--------------------------------------------------------------------------
    # ● カーブ実行
    #--------------------------------------------------------------------------
    def curve
    @c = 0
    return if @action_data[6] == 0
    @curve = N03.parabola([@action_data[6], -@action_data[6]], @move_time, 100, 4)
    end
    #--------------------------------------------------------------------------
    # ● ジャンプ実行
    #--------------------------------------------------------------------------
    def jump
    convert_jump
    return if @action_data[7] == [0,0]
    @jump = N03.parabola(@action_data[7].dup, @move_time, 100)
    end
    #--------------------------------------------------------------------------
    # ● J座標(ジャンプ高度)をH座標に変換
    #--------------------------------------------------------------------------
    def convert_jump
    @h += @j
    @j = 0
    @jump = []
    end
    #--------------------------------------------------------------------------
    # ● データベース戦闘アニメ実行
    #--------------------------------------------------------------------------
    def battle_anime
    data = @action_data.dup
    targets = N03.get_targets(data[2], @battler)
    return if targets == []
    data[8] = !data[8] if @mirror
    @set_damage = data[5]
    @damage_anime_data[0] = N03.get_attack_anime_id(data[1], @battler)
    @damage_anime_data[1] = data[8]
    @damage_anime_data[2] = data[7]
    @damage_anime_data[3] = data[6]
    @damage_anime_data[4] = data[9]
    @wait = N03.get_anime_time(@damage_anime_data[0]) - 2 if data[4]
    return if @set_damage
    for target in targets do display_anime(targets, target, data) end
    end
    #--------------------------------------------------------------------------
    # ● 武器アニメ開始
    #--------------------------------------------------------------------------
    def weapon_anime(anime_data)
    @weapon_end = true
    for i in 9...anime_data.size
    set_effect_data(anime_data[i]) if anime_data[i] != ""
    end
    end
    #--------------------------------------------------------------------------
    # ● アニメ飛ばし開始
    #--------------------------------------------------------------------------
    def move_anime
    @m_a_starter = []
    @m_a_targets = []
    starters = N03.get_targets(@action_data[2], @battler)
    targets = N03.get_targets(@action_data[3], @battler)
    return if starters == [] or targets == []
    single_start = true if starters != nil && @action_data[2] < 0
    single_start = true if @action_data[1][0] != 0 && $data_animations[N03.get_attack_anime_id(@action_data[1][0], @battler)].position == 3
    starters = [starters[0]] if single_start
    single_end = true if targets != nil && @action_data[3] < 0
    single_end = true if @action_data[1][1] != 0 && $data_animations[N03.get_attack_anime_id(@action_data[1][1], @battler)].position == 3
    targets = [targets[0]] if single_end
    se_flag = true
    for starter in starters
    for target in targets
    data = @action_data.dup
    data[17] = se_flag
    @effect_data.push(data)
    @m_a_targets.push(target)
    @m_a_starter.push(starter)
    se_flag = false
    end
    end
    end
    #--------------------------------------------------------------------------
    # ● スプライトセット通信
    #--------------------------------------------------------------------------
    def set_effect_data(data = @action)
    action_data = N03::ACTION[data]
    return if action_data == nil
    @effect_data.push(action_data.dup)
    end
    #--------------------------------------------------------------------------
    # ● 戦闘シーン通信のデータを格納
    #--------------------------------------------------------------------------
    def set_play_data(data = @action_data)
    @play_data = data.dup
    end
    #--------------------------------------------------------------------------
    # ● 戦闘アニメの表示
    #--------------------------------------------------------------------------
    def display_anime(targets, target, data)
    return if !N03.first_of_all_screen_anime(data[1], target, targets)
    target.animation_id = N03.get_attack_anime_id(data[1], @battler)
    target.animation_mirror = data[8]
    target.sv.anime_horming = data[3]
    target.sv.anime_camera_zoom = data[6]
    target.sv.anime_no_mirror = data[7]
    target.sv.anime_plus_z = data[9]
    end
    #--------------------------------------------------------------------------
    # ● 戦闘アニメ拡張データの初期化
    #--------------------------------------------------------------------------
    def reset_anime_data
    @anime_no_mirror = false
    @anime_horming = false
    @anime_camera_zoom = false
    @timing_targets = []
    @anime_plus_z = true
    end
    #--------------------------------------------------------------------------
    # ● カメラワーク
    #--------------------------------------------------------------------------
    def camera
    data = @action_data.dup
    N03.camera(@battler, data)
    @wait = data[4] if data[5]
    end
    #--------------------------------------------------------------------------
    # ● 画面のシェイク
    #--------------------------------------------------------------------------
    def shake
    data = @action_data.dup
    $sv_camera.shake(data[1], data[2], data[3])
    @wait = data[3] if data[4]
    end
    #--------------------------------------------------------------------------
    # ● 画面色調変更
    #--------------------------------------------------------------------------
    def color_effect
    case @action_data[1]
    when 0,1,2,3,4,5
    targets = N03.get_targets(@action_data[1], @battler)
    when 6
    screen = true
    when 7
    targets = [@battler] + @target_battler
    when 8
    screen = true
    targets = $game_troop.members + $game_party.battle_members - [@battler]
    when 9
    screen = true
    targets = $game_troop.members + $game_party.battle_members - [@battler] - @target_battler
    when 10
    screen = true
    targets = $game_troop.members + $game_party.battle_members
    end
    return if screen == nil && targets == []
    for target in targets do target.sv.color_set = @action_data[2] end if targets
    @wait = @action_data[2][4] if @action_data[3]
    return if !screen
    $sv_camera.color_set[1] = @action_data[2]
    $sv_camera.color_set[2] = @action_data[2]
    end
    #--------------------------------------------------------------------------
    # ● トランジション
    #--------------------------------------------------------------------------
    def transition
    $sv_camera.perform_transition(@action_data)
    end
    #--------------------------------------------------------------------------
    # ● ふきだしアニメ表示
    #--------------------------------------------------------------------------
    def balloon_anime
    @balloon_data = @action_data.dup
    end
    #--------------------------------------------------------------------------
    # ● ピクチャ表示
    #--------------------------------------------------------------------------
    def picture_set
    @picture = true
    set_effect_data
    end
    #--------------------------------------------------------------------------
    # ● ステート操作
    #--------------------------------------------------------------------------
    def state_set
    targets = N03.get_targets(@action_data[1], @battler)
    return if targets == []
    case @action_data[2]
    when 1 ; targets = [targets[rand(targets.size)]]
    when 2 ; targets -= @battler if targets.include?(@battler)
    end
    for target in targets
    for id in @action_data[4]
    target.add_state(id) if @action_data[3] == "+"
    target.remove_state(id) if @action_data[3] == "-"
    end
    end
    end
    #--------------------------------------------------------------------------
    # ● FPS変更
    #--------------------------------------------------------------------------
    def fps
    Graphics.frame_rate = @action_data[1]
    start_action
    end
    #--------------------------------------------------------------------------
    # ● バトラー画像変更の場合
    #--------------------------------------------------------------------------
    def graphics_change
    @graphics_change = true
    return @battler.graphics_change(@action_data[3]) if !@battler.actor?
    @pre_change_data = [@battler.character_name, @battler.character_index, @battler.face_name, @battler.face_index] if @pre_change_data == nil && !@action_data[1]
    if @action_data[4] == []
    face_name = @battler.face_name
    face_index = @battler.face_index
    else
    face_name = @action_data[4][1]
    face_index = @action_data[4][0]
    end
    @battler.set_graphic(@action_data[3], @action_data[2], face_name, face_index)
    end
    #--------------------------------------------------------------------------
    # ● スキル派生
    #--------------------------------------------------------------------------
    def derivating_skill
    # 未修得スキルは派生不可なら
    return if !@action_data[1] && !@battler.skill_learn?($data_skills[@action_data[3]])
    # コスト不足は派生不可なら
    return if !@action_data[2] && !@battler.skill_cost_payable?($data_skills[@action_data[3]])
    # 派生
    @derivation_skill_id = @action_data[3]
    # 以降のアクションをキャンセル
    @full_action = []
    end
    #--------------------------------------------------------------------------
    # ● BGM/BGS/SE演奏
    #--------------------------------------------------------------------------
    def sound
    pitch = @action_data[2]
    vol = @action_data[3]
    name = @action_data[4]
    case @action_data[1]
    when "se"
    Audio.se_play("Audio/SE/" + name, vol, pitch)
    when "bgm"
    # 名前指定のない場合、現在のBGMを変 ないように
    name = RPG::BGM.last.name if @action_data[4] == ""
    Audio.bgm_play("Audio/BGM/" + name, vol, pitch)
    when "bgs"
    name = RPG::BGS.last.name if @action_data[4] == ""
    Audio.bgs_play("Audio/BGS/" + name, vol, pitch)
    end
    end
    #--------------------------------------------------------------------------
    # ● ムービーの再生
    #--------------------------------------------------------------------------
    def movie
    Graphics.play_movie('Movies/' + @action_data[1])
    end
    #--------------------------------------------------------------------------
    # ● ゲームスイッチ操作
    #--------------------------------------------------------------------------
    def switches
    for id in @action_data[1]
    $game_switches[id] = true if id > 0
    $sv_camera.switches[id.abs] = true if id < 0
    end
    for id in @action_data[2]
    $game_switches[id] = false if id > 0
    $sv_camera.switches[id.abs] = false if id < 0
    end
    $sv_camera.program_check
    end
    #--------------------------------------------------------------------------
    # ● ゲーム変数操作
    #--------------------------------------------------------------------------
    def variable
    # オペランドチェック
    operand = @action_data[3]
    operand = $game_variables[@action_data[3].abs] if @action_data[3] < 0
    # 変数操作で分岐
    case @action_data[2]
    when 0 ; $game_variables[@action_data[1]] = operand # 代入
    when 1 ; $game_variables[@action_data[1]] += operand # 加算
    when 2 ; $game_variables[@action_data[1]] -= operand # 減算
    when 3 ; $game_variables[@action_data[1]] *= operand # 乗算
    when 4 ; $game_variables[@action_data[1]] /= operand # 除算
    when 5 ; $game_variables[@action_data[1]] %= operand # 剰余
    end
    end
    #--------------------------------------------------------------------------
    # ● 条件分岐 (ゲームスイッチ)
    #--------------------------------------------------------------------------
    def nece_1
    judgment = $game_switches[@action_data[1]] == @action_data[2] if @action_data[1] > 0
    judgment = $sv_camera.switches[@action_data[1].abs] == @action_data[2] if @action_data[1] < 0
    action_diverging(judgment, @action_data[3])
    end
    #--------------------------------------------------------------------------
    # ● 条件分岐 (ゲーム変数)
    #--------------------------------------------------------------------------
    def nece_2
    variable = $game_variables[@action_data[1]]
    num = @action_data[2]
    num = $game_variables[@action_data[2].abs] if num < 0
    case @action_data[3]
    when 0 ; judgment = variable == num
    when 1 ; judgment = variable < num
    when 2 ; judgment = variable > num
    end
    action_diverging(judgment, @action_data[4])
    end
    #--------------------------------------------------------------------------
    # ● 条件分岐 (ステート)
    #--------------------------------------------------------------------------
    def nece_3
    targets = N03.get_targets(@action_data[1], @battler)
    return if targets == []
    member_num = @action_data[4]
    member_num = targets.size if @action_data[4] == 0 && targets.size > 1
    hit_count = 0
    miss_count = 0
    for target in targets
    hit_count += 1 if target.state?(@action_data[2])
    miss_count += 1 if !target.state?(@action_data[2])
    end
    case @action_data[3]
    when 0 ; judgment = hit_count >= member_num
    when 1 ; judgment = miss_count >= member_num
    end
    action_diverging(judgment, @action_data[5])
    end
    #--------------------------------------------------------------------------
    # ● 条件分岐 (スキル)
    #--------------------------------------------------------------------------
    def nece_4
    targets = N03.get_targets(@action_data[1], @battler)
    return if targets == []
    member_num = @action_data[4]
    member_num = targets.size if @action_data[4] == 0 && targets.size > 1
    hit_count = 0
    miss_count = 0
    for target in targets
    hit_count += 1 if target.skill_learn?($data_skills[@action_data[2]]) && target.skill_conditions_met?($data_skills[@action_data[2]])
    miss_count += 1 if !target.skill_learn?($data_skills[@action_data[2]]) or !target.skill_conditions_met?($data_skills[@action_data[2]])
    end
    case @action_data[3]
    when 0 ; judgment = hit_count >= member_num
    when 1 ; judgment = miss_count >= member_num
    end
    action_diverging(judgment, @action_data[5])
    end
    #--------------------------------------------------------------------------
    # ● 条件分岐 (パラメータ)
    #--------------------------------------------------------------------------
    def nece_5
    targets = N03.get_targets(@action_data[1], @battler)
    return if targets == []
    member_num = @action_data[5]
    member_num = targets.size if @action_data[5] == 0 && targets.size > 1
    hit_count = 0
    for target in targets
    hit_count += 1 if target.comparison_parameter([@action_data[2],@action_data[3],@action_data[4]])
    end
    judgment = hit_count >= member_num
    action_diverging(judgment, @action_data[6])
    end
    #--------------------------------------------------------------------------
    # ● 条件分岐 (装備)
    #--------------------------------------------------------------------------
    def nece_6
    targets = N03.get_targets(@action_data[1], @battler)
    return if targets == []
    member_num = @action_data[5]
    member_num = targets.size if @action_data[5] == 0 && targets.size > 1
    hit_count = 0
    miss_count = 0
    for target in targets
    hit_count += 1 if target.comparison_equip([@action_data[2],@action_data[3]])
    miss_count += 1 if !target.comparison_equip([@action_data[2],@action_data[3]])
    end
    case @action_data[4]
    when 0 ; judgment = hit_count >= member_num
    when 1 ; judgment = miss_count >= member_num
    end
    action_diverging(judgment, @action_data[6])
    end
    #--------------------------------------------------------------------------
    # ● 条件分岐 (スクリプト)
    #--------------------------------------------------------------------------
    def nece_7
    judgment = eval(@action_data[2])
    action_diverging(judgment, @action_data[1])
    end
    #--------------------------------------------------------------------------
    # ● アクション分岐
    #--------------------------------------------------------------------------
    def action_diverging(judgment, kind)
    result = 0
    if judgment
    result = 1 if kind == 1
    result = 2 if kind == 2
    else
    result = 1 if kind == 0
    end
    # フルアクション終了
    return @full_action = [] if result == 2
    # 次のアクションを除去
    @full_action.shift if result == 1
    set_action
    # 次のアクションを実行
    @action_data = N03::ACTION[@action]
    next_action
    end
    #--------------------------------------------------------------------------
    # ● セカンドターゲット操作
    #--------------------------------------------------------------------------
    def second_targets_set
    targets = N03.get_targets(@action_data[1], @battler)
    for target in targets
    targets.delete(target) if @action_data[2][1] == 1 && target.index != @action_data[2][0]
    targets.delete(target) if @action_data[2][1] == 2 && target.index == @action_data[2][0].abs
    targets.delete(target) if @action_data[3] > 0 && target.id != @action_data[3]
    targets.delete(target) if @action_data[3] < 0 && target.id == @action_data[3].abs
    targets.delete(target) if @action_data[4] > 0 && !target.state?(@action_data[4])
    targets.delete(target) if @action_data[4] < 0 && target.state?(@action_data[4].abs)
    targets.delete(target) if @action_data[5] > 0 && !target.skill_conditions_met?($data_skills[@action_data[5]])
    targets.delete(target) if @action_data[5] < 0 && target.skill_conditions_met?($data_skills[@action_data[5].abs])
    targets.delete(target) if !target.comparison_parameter(@action_data[6])
    targets.delete(target) if !@action_data[7][1].include?(0) && !target.comparison_equip(@action_data[7])
    end
    return @second_targets = [] if targets.size == 0
    case @action_data[8]
    when 1 ; targets = [targets[rand(targets.size)]]
    when 2 ; targets.delete(@battler)
    end
    return @second_targets = [] if targets.size == 0
    @second_targets = targets
    case @action_data[9]
    when 0 ; return
    when 1 ; set_play_data(["second_targets_set"])
    when 2 ; set_play_data(["targets_set"])
    end
    @wait += 1
    end
    #--------------------------------------------------------------------------
    # ● コモンイベント呼び出し
    #--------------------------------------------------------------------------
    def call_common_event
    $game_temp.reserve_common_event(@action_data[1])
    $sv_camera.event = true
    @event_fix = @action_data[2]
    end
    #--------------------------------------------------------------------------
    # ● ダメージアニメ
    #--------------------------------------------------------------------------
    def damage_anime(delay_time = 12)
    anime(N03.get_attack_anime_id(-3, @battler), wait = true)
    action_play
    @wait -= delay_time
    @full_action.unshift("eval('@damage_anime_data = []
    @set_damage = true')")
    end
    #--------------------------------------------------------------------------
    # ● 通常コラプス
    #--------------------------------------------------------------------------
    def normal_collapse
    @collapse = true
    return
    end
    #--------------------------------------------------------------------------
    # ● 初期位置変更
    #--------------------------------------------------------------------------
    def change_base_position
    @base_x = @x
    @base_y = @y
    @base_h = @h
    end
    #--------------------------------------------------------------------------
    # ● 強制アクション実行
    #--------------------------------------------------------------------------
    def force_act
    target(@full_action.shift)
    end
    #--------------------------------------------------------------------------
    # ● 強制アクション実行 (セカンドターゲット)
    #--------------------------------------------------------------------------
    def force_act2
    target2(@full_action.shift)
    end
    #--------------------------------------------------------------------------
    # ● 個別処理開始
    #--------------------------------------------------------------------------
    def individual_start
    @individual_targets = @target_battler.dup
    @remain_targets = @target_battler.dup
    @target_battler = [@individual_targets[0]]
    # リピート部分のアクションを保持
    @individual_act = @full_action.dup
    end
    #--------------------------------------------------------------------------
    # ● 個別処理終了
    #--------------------------------------------------------------------------
    def individual_end
    @individual_targets.shift
    for target in @individual_targets
    @individual_targets.shift if target.dead?
    end
    # ターゲットが残っているなら行動リ ート
    return @target_battler = @remain_targets if @individual_targets.size == 0
    @full_action = @individual_act.dup
    @target_battler = [@individual_targets[0]]
    end
    #--------------------------------------------------------------------------
    # ● ループ開始
    #--------------------------------------------------------------------------
    def loop_start
    # ループ部分のアクションを保持
    @loop_act = @full_action.dup
    end
    #--------------------------------------------------------------------------
    # ● ループ終了
    #--------------------------------------------------------------------------
    def loop_end
    # 行動リピート
    @full_action = @loop_act.dup if @loop_act != []
    end
    #--------------------------------------------------------------------------
    # ● 次の行動者へ移行
    #--------------------------------------------------------------------------
    def next_battler
    @action_end = true
    @active = false
    end
    #--------------------------------------------------------------------------
    # ● 画像変更フラグ
    #--------------------------------------------------------------------------
    def set_change
    @change_up = true
    end
    #--------------------------------------------------------------------------
    # ● 戦闘シーン通信
    #--------------------------------------------------------------------------
    def play_data
    data = @play_data
    @play_data = []
    return data
    end
    #--------------------------------------------------------------------------
    # ● ショートカットコマンド
    #--------------------------------------------------------------------------
    def anime(anime_id, wait = true)
    @action_data = ["anime",anime_id,1,false,wait,false,true,false]
    end
    def anime_me(anime_id, wait = true)
    @action_data = ["anime",anime_id,0,false,wait,false,true,false]
    end
    def se(file, pitch = 100)
    @action_data = ["sound", "se", pitch, 100, file]
    end
    def target(act)
    for target in @target_battler do target.sv.force_action = act end
    end
    def target2(act)
    for target in @second_targets do target.sv.force_action = act end
    end
    def delay(time)
    @wait = @battler.index * time
    end
    #--------------------------------------------------------------------------
    # ● バトラーのIDを取得
    #--------------------------------------------------------------------------
    def id
    return @battler.id if @battler.actor?
    return -@battler.id
    end
    #--------------------------------------------------------------------------
    # ● 被クリティカルフラグを取得
    #--------------------------------------------------------------------------
    def critical?
    return @battler.result.critical
    end
    #--------------------------------------------------------------------------
    # ● 被回復フラグを取得
    #--------------------------------------------------------------------------
    def recovery?
    recovery = false
    recovery = true if @battler.result.hp_damage < 0
    recovery = true if @battler.result.mp_damage < 0
    recovery = true if @battler.result.tp_damage < 0
    return recovery
    end
    #--------------------------------------------------------------------------
    # ● 被スキルIDを取得
    #--------------------------------------------------------------------------
    def damage_skill_id
    return @damage_skill_id
    end
    #--------------------------------------------------------------------------
    # ● 被アイテムIDを取得
    #--------------------------------------------------------------------------
    def damage_item_id
    return @damage_item_id
    end
    #--------------------------------------------------------------------------
    # ● 装備武器を取得
    #--------------------------------------------------------------------------
    def weapon_id
    return 0 if !@battler.weapons[0]
    return @battler.weapons[0].id
    end
    #--------------------------------------------------------------------------
    # ● 装備武器のタイプを取得
    #--------------------------------------------------------------------------
    def weapon_type
    return 0 if !@battler.weapons[0]
    return @battler.weapons[0].wtype_id
    end
    #--------------------------------------------------------------------------
    # ● 盾を装備しているか
    #--------------------------------------------------------------------------
    def shield?
    for armor in @battler.armors do return true if armor != nil && armor.etype_id == 1 end
    return false
    end
    #--------------------------------------------------------------------------
    # ● ダメージがあるか
    #--------------------------------------------------------------------------
    def damage_zero?
    return @battler.result.hp_damage == 0 && @battler.result.mp_damage == 0 && @battler.result.tp_damage == 0
    end
    #--------------------------------------------------------------------------
    # ● スキルIDを取得
    #--------------------------------------------------------------------------
    def skill_id
    return @counter_id if @counter_id != 0
    return 0 if @battler.current_action == nil or @battler.current_action.item == nil
    return 0 if @battler.current_action.item.is_a?(RPG::Item)
    return @battler.current_action.item.id
    end
    #--------------------------------------------------------------------------
    # ● スキルのタイプを取得
    #--------------------------------------------------------------------------
    def skill_type
    return 0 if skill_id == 0
    return $data_skills[skill_id].stype_id
    end
    #--------------------------------------------------------------------------
    # ● スキル名を取得
    #--------------------------------------------------------------------------
    def skill_name
    return "" if skill_id == 0
    return $data_skills[skill_id].name
    end
    #--------------------------------------------------------------------------
    # ● アイテムIDを取得
    #--------------------------------------------------------------------------
    def item_id
    return 0 if @battler.current_action == nil or @battler.current_action.item == nil
    return @battler.current_action.item.id
    end
    #--------------------------------------------------------------------------
    # ● 攻撃アクション
    #--------------------------------------------------------------------------
    def attack_action(item)
    return skill_action if item.is_a?(RPG::Skill)
    return item_action
    end
    #--------------------------------------------------------------------------
    # ● ダメージアクションベース
    #--------------------------------------------------------------------------
    def damage_action_base(item)
    @damage_skill_id = 0
    @damage_item_id = 0
    @damage_skill_id = item.id if item.is_a?(RPG::Skill)
    @damage_item_id = item.id if item.is_a?(RPG::Item)
    end
    #--------------------------------------------------------------------------
    # ● ダメージアクション
    #--------------------------------------------------------------------------
    def damage_action(attacker, item)
    damage_action_base(item)
    act = damage(attacker)
    return if @active
    start_action(act) if act != nil
    end
    #--------------------------------------------------------------------------
    # ● 回避アクション
    #--------------------------------------------------------------------------
    def evasion_action(attacker, item)
    damage_action_base(item)
    act = evasion(attacker)
    return if @active
    start_action(act) if act != nil
    end
    #--------------------------------------------------------------------------
    # ● ミスアクション
    #--------------------------------------------------------------------------
    def miss_action(attacker, item)
    damage_action_base(item)
    act = miss(attacker)
    return if @active
    start_action(act) if act != nil
    end
    #--------------------------------------------------------------------------
    # ● 閃きスクリプト併用処理
    #--------------------------------------------------------------------------
    def flash_action
    return "閃き"
    end

    end


    #================================================= =============================
    # ■ module N03
    #------------------------------------------------------------------------------
    #  サイドビューバトルのモジュール す。
    #================================================= =============================
    module N03
    #--------------------------------------------------------------------------
    # ● バトラーの敵グループを取得
    #--------------------------------------------------------------------------
    def self.get_enemy_unit(battler)
    return $game_troop if battler.actor?
    return $game_party
    end
    #--------------------------------------------------------------------------
    # ● バトラーの味方グループを取得
    #--------------------------------------------------------------------------
    def self.get_party_unit(battler)
    return $game_party if battler.actor?
    return $game_troop
    end
    #--------------------------------------------------------------------------
    # ● 戦闘アニメ時間の取得
    #--------------------------------------------------------------------------
    def self.get_anime_time(anime_id)
    return 0 if anime_id <= 0
    return $data_animations[anime_id].frame_max * 4
    end
    #--------------------------------------------------------------------------
    # ● 攻撃アニメの取得
    #--------------------------------------------------------------------------
    def self.get_attack_anime_id(kind, battler)
    return $data_skills[battler.sv.counter_id].animation_id if kind == -3 && battler.sv.counter_id != 0
    case kind
    when -1 ; anime_id = battler.atk_animation_id1
    when -2 ; anime_id = battler.atk_animation_id2
    when -3
    if battler.current_action != nil
    anime_id = battler.current_action.item.animation_id if battler.current_action.item != nil
    end
    else ; anime_id = kind
    end
    case anime_id
    when -1 ; anime_id = battler.atk_animation_id1
    when -2 ; anime_id = battler.atk_animation_id2
    end
    return anime_id if anime_id
    return 0
    end
    #--------------------------------------------------------------------------
    # ● 戦闘アニメデータをセット
    #--------------------------------------------------------------------------
    def self.set_damage_anime_data(targets, target, data)
    return if !first_of_all_screen_anime(data[0], target, targets)
    target.animation_id = data[0]
    target.animation_mirror = data[1]
    target.sv.anime_no_mirror = data[2]
    target.sv.anime_camera_zoom = data[3]
    target.sv.anime_plus_z = data[4]
    end
    #--------------------------------------------------------------------------
    # ● ターゲットの取得
    #--------------------------------------------------------------------------
    def self.get_targets(kind, battler)
    case kind.abs
    when 0 ; return [battler].dup
    when 1 ; return battler.sv.target_battler.dup
    when 2 ; return get_enemy_unit(battler).members.dup
    when 3 ; return get_party_unit(battler).members.dup
    when 4 ; return $game_troop.members.dup + $game_party.battle_members.dup
    when 5 ; return battler.sv.second_targets.dup
    end
    end
    #--------------------------------------------------------------------------
    # ● ターゲットの座標を取得
    #--------------------------------------------------------------------------
    def self.get_targets_position(targets, horming, m_a = nil)
    return [0,0,0] if targets == nil && !$sv_camera.mirror
    return [Graphics.width,0,0] if targets == nil && $sv_camera.mirror
    x = y = h = 0
    for i in 0...targets.size
    x += targets[i].sv.base_x if !horming
    y += targets[i].sv.base_y if !horming
    h += targets[i].sv.base_h if !horming
    x += targets[i].sv.x if horming
    y += targets[i].sv.y if horming
    h += targets[i].sv.h if horming
    y -= targets[i].sv.ch * 100 if m_a == 0
    y -= targets[i].sv.ch * 50 if m_a == 1
    end
    return [x / targets.size, y / targets.size, h / targets.size]
    end
    #--------------------------------------------------------------------------
    # ● 速度を時間に変換
    #--------------------------------------------------------------------------
    def self.distanse_calculation(time, target_position, self_position, distanse_move)
    return time if !distanse_move
    distanse_x = self_position[0] - target_position[0]
    distanse_x = target_position[0] - self_position[0] if target_position[0] > self_position[0]
    distanse_y = self_position[1] - target_position[1]
    distanse_y = target_position[1] - self_position[1] if target_position[1] > self_position[1]
    if self_position[2] != nil && target_position[2] != nil
    distanse_h = self_position[2] - target_position[2]
    distanse_h = target_position[2] - self_position[2] if target_position[2] > self_position[2]
    else
    distanse_h = 0
    end
    distanse = [distanse_x, distanse_y, distanse_h].max
    return distanse / (time * 100) + 1
    end
    #--------------------------------------------------------------------------
    # ● 放物線移動計算
    #--------------------------------------------------------------------------
    def self.parabola(data, time, size, type = 1)
    move_data = data
    move_data[0] *= size
    move_data[1] *= size
    move = []
    move_d = []
    for i in 0...time / 2
    move[i] = move_data[0]
    move_d[i] = move_data[1]
    move_data[0] = move_data[0] * type / (1 + type)
    move_data[1] = move_data[1] * type / (1 + type)
    end
    move = move + move_d.reverse!
    move.reverse!
    adjust = move.inject(0) {|result, item| result + item }
    move[move.size - 1] += adjust if data[0] == data[1] && adjust != 0
    move.unshift(0) if time % 2 != 0
    return move
    end
    #--------------------------------------------------------------------------
    # ● 反転値
    #--------------------------------------------------------------------------
    def self.mirror_num(mirror)
    return 1 if !mirror
    return -1
    end
    #--------------------------------------------------------------------------
    # ● カメラワーク
    #--------------------------------------------------------------------------
    def self.camera(battler, data)
    battler = $game_party.battle_members[0] if !battler
    cx = data[2][0] * 100
    cy = data[2][1] * 100
    return $sv_camera.move(cx, cy, data[3], data[4], true) if data[1] == 6
    targets = self.get_targets(data[1], battler)
    return if targets == nil or targets == []
    position = self.get_targets_position(targets, true)
    $sv_camera.move(position[0], position[1] - position[2], data[3], data[4], false)
    end
    #--------------------------------------------------------------------------
    # ● コラプス禁止
    #--------------------------------------------------------------------------
    def self.immortaling
    # 全員に不死身付与
    for member in $game_party.battle_members + $game_troop.members
    # イベント操作等で不死身設定になっ いたら解除を無効にするフラグを立 る
    member.sv.immortal = true if member.state?(N03::IMMORTAL_ID)
    member.add_state(N03::IMMORTAL_ID)
    end
    return true
    end
    #--------------------------------------------------------------------------
    # ● コラプス許可
    #--------------------------------------------------------------------------
    def self.unimmortaling
    # 全員の不死身化解除(イベント等で不 身設定がされていれば除く)
    for member in $game_party.battle_members + $game_troop.members
    next if member.dead?
    # 不死身ステートが行動中に解除され いた場合、解除無効を解除
    member.sv.immortal = false if !member.state?(N03::IMMORTAL_ID) && member.sv.immortal
    next member.sv.immortal = false if member.sv.immortal
    member.remove_state(N03::IMMORTAL_ID)
    next if member.hp != 0
    member.add_state(1)
    member.perform_collapse_effect
    member.sv.action_terminate
    end
    return false
    end
    #--------------------------------------------------------------------------
    # ● スキル派生
    #--------------------------------------------------------------------------
    def self.derived_skill(battler)
    battler.force_action(battler.sv.derivation_skill_i d, -2)
    BattleManager.unshift_action_battlers(battler)
    end
    #--------------------------------------------------------------------------
    # ● ダメージの作成
    #--------------------------------------------------------------------------
    def self.set_damage(battler, hp_damage, mp_damage)
    battler.result.hp_damage = hp_damage
    battler.result.mp_damage = mp_damage
    end
    #--------------------------------------------------------------------------
    # ● ターゲット生死確認
    #--------------------------------------------------------------------------
    def self.targets_alive?(targets)
    return false if targets == []
    for target in targets do return true if !target.dead? end
    return false
    end
    #--------------------------------------------------------------------------
    # ● ターゲットをセカンドターゲットへ
    #--------------------------------------------------------------------------
    def self.s_targets(battler)
    battler.sv.target_battler = battler.sv.second_targets
    return battler.sv.second_targets
    end
    #--------------------------------------------------------------------------
    # ● セカンドターゲットをターゲットへ
    #--------------------------------------------------------------------------
    def self.targets_set(battler)
    battler.sv.second_targets = battler.current_action.make_targets.compact
    battler.sv.target_battler = battler.sv.second_targets
    end
    #--------------------------------------------------------------------------
    # ● 戦闘アニメ実行判定 (対象:画面時は最初のターゲットの アニメ実行)
    #--------------------------------------------------------------------------
    def self.first_of_all_screen_anime(anime_id, target, targets)
    anime = $data_animations[anime_id]
    return false if !anime
    return true if anime.position != 3
    return false if anime.position == 3 && target != targets[0]
    targets.delete(target)
    target.sv.timing_targets = targets
    return true
    end
    #--------------------------------------------------------------------------
    # ● 戦闘不能付加攻撃か
    #--------------------------------------------------------------------------
    def self.dead_attack?(battler, item)
    for state in battler.atk_states
    return true if state == battler.death_state_id
    end
    for effect in item.effects
    return true if effect.code == 21 && effect.data_id == battler.death_state_id
    end
    return false
    end
    end

    #================================================= =============================
    # ■ Sprite_Weapon
    #------------------------------------------------------------------------------
    #  ウエポン表示用のスプライトです
    #================================================= =============================
    class Sprite_Weapon < Sprite_Base
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数 
    #--------------------------------------------------------------------------
    attr_reader :index # ウエポン画像配列のインデックス
    attr_reader :battler # 画像が参照しているバトラー
    attr_reader :move_time # 画像が目標に到達するまでの時間
    attr_reader :through # 貫通フラグ
    attr_reader :action_end # 武器アクション終了フラグ
    attr_reader :action_end_cancel # 武器アクション終了フラグ
    attr_reader :hit_position # 画像が目標に到達した時の座標
    attr_accessor :hit_anime_id # 画像が目標に到達した時のアニメID
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    def initialize(viewport, index, battler)
    super(viewport)
    @index = index
    @battler = battler
    @position_x = @position_y = 0
    @o = 0
    @real_x = @real_y = 0
    @mirror = @battler.sv.mirror
    reset
    set_action
    end
    #--------------------------------------------------------------------------
    # ● 初期化
    #--------------------------------------------------------------------------
    def reset
    @z_plus = 0
    @weapon_data = []
    @move_data = []
    @move_x = 0
    @move_y = 0
    @orbit = []
    @through = false
    @distanse_move = false
    @weapon_width = 0
    @weapon_height = 0
    @anime_time = 0
    @anime_position = 1
    @move_time = 0
    @hit_anime_id = 0
    @move_anime = true
    @action_end = false
    @action_end_cancel = false
    reset_position
    end
    #--------------------------------------------------------------------------
    # ● アクションをセット
    #--------------------------------------------------------------------------
    def set_action
    return if @battler.sv.effect_data == []
    weapon_anime if @battler.sv.effect_data[0][0] == "wp"
    move_anime if @battler.sv.effect_data[0][0] == "m_a"
    @battler.sv.effect_data.shift
    end
    #--------------------------------------------------------------------------
    # ● 武器アニメ実行
    #--------------------------------------------------------------------------
    def weapon_anime
    @weapon_data = @battler.sv.effect_data[0].dup
    set_graphics
    set_ox
    set_weapon_move
    end
    #--------------------------------------------------------------------------
    # ● アニメ移動実行
    #--------------------------------------------------------------------------
    def move_anime
    @move_data = @battler.sv.effect_data[0].dup
    # ターゲットを取得
    @target_battler = [@battler.sv.m_a_targets.shift]
    @target_battler = N03.get_targets(@move_data[3], @battler) if @move_data[3] < 0
    set_move
    return if @move_data[16] == ""
    weapon_data = N03::ACTION[@move_data[16]]
    return if weapon_data == nil
    @weapon_data = weapon_data.dup
    set_graphics
    set_ox
    set_weapon_move
    end
    #--------------------------------------------------------------------------
    # ● 武器画像を取得
    #--------------------------------------------------------------------------
    def set_graphics
    # 武器に依存しない画像設定がある場
    if @weapon_data[13] != ""
    self.bitmap = Cache.character(@weapon_data[13]).dup
    @weapon_width = self.bitmap.width
    @weapon_height = self.bitmap.height
    return
    end
    # 武器を取得
    weapon = @battler.weapons[0]
    # 逆手装備を取得
    if @weapon_data[10]
    weapon = nil
    for armor in @battler.armors do break weapon = armor if armor.is_a?(RPG::Armor) && armor.etype_id == 1 end
    weapon = @battler.weapons[1] if !weapon
    end
    # 武器がなければ処理をキャンセル
    return if weapon == nil
    # インデックスを取得
    file_index = @weapon_data[12]
    # アイコンを利用するなら
    if @weapon_data[1] == 0
    icon_index = weapon.icon_index
    self.bitmap = Cache.system("Iconset" + file_index).dup
    self.src_rect.set(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    @weapon_width = @weapon_height = 24
    # 独自画像指定
    else
    file_name = @battler.sv.weapon_graphic(weapon.id, weapon.wtype_id) if weapon.is_a?(RPG::Weapon)
    file_name = @battler.sv.shield_graphic(weapon.id, weapon.atype_id) if weapon.is_a?(RPG::Armor)
    self.bitmap = Cache.character(file_name + file_index).dup
    @weapon_width = self.bitmap.width
    @weapon_height = self.bitmap.height
    return if @weapon_data[1] == 1
    # 2003仕様の武器アニメ
    @weapon_width /= @battler.sv.max_pattern[0]
    end
    end
    #--------------------------------------------------------------------------
    # ● 画像の原点を取得
    #--------------------------------------------------------------------------
    def set_ox
    # 反転時は設定を逆に
    if @mirror
    case @weapon_data[6]
    when 1 ; @weapon_data[6] = 2 # 左上→右上に
    when 2 ; @weapon_data[6] = 1 # 右上→左上に
    when 3 ; @weapon_data[6] = 4 # 左下→右下に
    when 4 ; @weapon_data[6] = 3 # 右下→左下に
    end
    end
    # 原点を設定
    case @weapon_data[6]
    when 0 # 中心
    self.ox = @weapon_width / 2
    self.oy = @weapon_height / 2
    when 1 # 左上
    self.ox = 0
    self.oy = 0
    when 2 # 右上
    self.ox = @weapon_width
    self.oy = 0
    when 3 # 左下
    self.ox = 0
    self.oy = @weapon_height
    when 4 # 右下
    self.ox = @weapon_width
    self.oy = @weapon_height
    when 5 # バトラーと同じ
    self.ox = @weapon_width / 2
    self.oy = @weapon_height
    end
    end
    #--------------------------------------------------------------------------
    # ● バトラーの座標を取得
    #--------------------------------------------------------------------------
    def set_battler_position
    @position_x = @battler.sv.x + @weapon_data[3][0] * N03.mirror_num(@mirror) * 100
    @position_y = (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.c - @battler.sv.oy_adjust) + @weapon_data[3][1] * 100
    reset_position
    end
    #--------------------------------------------------------------------------
    # ● 座標を初期化
    #--------------------------------------------------------------------------
    def reset_position
    @real_x = @position_x / 100
    @real_y = @position_y / 100
    @real_zoom_x = 1
    @real_zoom_y = 1
    end
    #--------------------------------------------------------------------------
    # ● 戦闘アニメを表示
    #--------------------------------------------------------------------------
    def set_animation(anime_id)
    return if $data_animations[anime_id] == nil
    @anime_position = $data_animations[anime_id].position
    @horming = true
    @horming = false if @anime_position == 3
    @anime_camera_zoom = true
    @anime_no_mirror = false
    start_animation($data_animations[anime_id], @mirror)
    timings = $data_animations[anime_id].timings
    end
    #--------------------------------------------------------------------------
    # ● ヒット時の戦闘アニメ実行
    #--------------------------------------------------------------------------
    def set_hit_animation(position_data, hit_anime_id, target)
    return if $data_animations[hit_anime_id] == nil
    @real_x = position_data[0]
    @real_y = position_data[1]
    @position_x = position_data[0] * 100
    @position_y = position_data[1] * 100
    self.z = position_data[2]
    @z_plus = 1000
    @action_end = false
    @horming = true
    set_animation(hit_anime_id)
    @anime_time = $data_animations[hit_anime_id].frame_max * 4
    @timing_targets = [target]
    @move_time = @hit_anime_id = 0
    @weapon_data = []
    end
    #--------------------------------------------------------------------------
    # ● タイミングバトラー追加
    #--------------------------------------------------------------------------
    def timing_battler_set(target)
    @timing_targets.push(target)
    end
    #--------------------------------------------------------------------------
    # ● 武器の動きを取得
    #--------------------------------------------------------------------------
    def set_weapon_move
    # 開始位置を取得
    set_battler_position if @move_time == 0
    @z_plus = 50 if @z_plus == 0 && @weapon_data[9]
    self.z = @battler.sv.z + @z_plus
    # 反転処理
    @mirror = !@mirror if @weapon_data[7]
    self.mirror = @mirror
    # 更新パターンをセット
    set_pattern
    @max_pattern = 2 if @max_pattern == 1
    # 動きを計算
    @weapon_move_data = []
    @weapon_angle_data = []
    @weapon_zoom_data = []
    num = N03.mirror_num(@mirror)
    for i in 0...@max_pattern
    move_data_x = @weapon_data[2][0] * num * 100 * i / (@max_pattern - 1)
    move_data_y = @weapon_data[2][1] * 100 * i / (@max_pattern - 1)
    move_angle = @weapon_data[4] * num + (@weapon_data[5] * num - @weapon_data[4] * num) * i / (@max_pattern - 1)
    move_zoom_x = 1 + (@weapon_data[8][0] - 1) * i / (@max_pattern - 1)
    move_zoom_y = 1 + (@weapon_data[8][1] - 1) * i / (@max_pattern - 1)
    @weapon_move_data.push([move_data_x, move_data_y])
    @weapon_angle_data.push(move_angle)
    @weapon_zoom_data.push([move_zoom_x, move_zoom_y])
    end
    end
    #--------------------------------------------------------------------------
    # ● 更新パターン
    #--------------------------------------------------------------------------
    def set_pattern
    if @weapon_data[11] == -1
    return @max_pattern = @battler.sv.max_pattern[0] if @battler.sv.pattern_type != 0
    @count = @battler.sv.pattern_time
    @max_count = @battler.sv.pattern_time
    @max_pattern = @battler.sv.max_pattern[0]
    @repeat = false
    else
    @count = @weapon_data[11][0]
    @max_count = @weapon_data[11][0]
    @max_pattern = @weapon_data[11][1]
    @repeat = @weapon_data[11][2]
    end
    @pattern = 0
    end
    #--------------------------------------------------------------------------
    # ● 移動実行
    #--------------------------------------------------------------------------
    def set_move
    # 戦闘アニメを取得
    set_animation(@move_data[1][0]) if $data_animations[@move_data[1][0]] != nil && $data_animations[@move_data[1][0]].position != 3
    @anime_camera_zoom = @move_data[13]
    @loop = @move_data[14]
    @loop = false if @move_data[1][0] == 0
    @anime_no_mirror = @move_data[15]
    @se_flag = @move_data[17]
    # 開始位置を取得
    start_position
    @z_plus = 1000 if @move_data[9]
    # ターゲットバトラー画像にこのアニ のSEとタイミング設定を反映させる
    @timing_targets = @target_battler
    # 座標計算
    @move_x = @move_data[5][0] * 100 * N03.mirror_num(@mirror)
    @move_y = @move_data[5][1] * 100
    # 時間計算か速度計算か
    @distanse_move = true if @move_data[6] > 0
    @move_time = @move_data[6].abs
    # 時間0の場合、アニメが設定されてい ばアニメ表示時間に合わせる
    if @move_time == 0
    @move_time = $data_animations[@move_data[1][0]].frame_max * 4 if $data_animations[@move_data[1][0]]
    @move_time = 1 if !$data_animations[@move_data[1][0]]
    @distanse_move = false
    end
    # 貫通タイプの場合
    @through = true if @move_data[7] == 1
    @auto_through_flag = false
    @auto_through_flag = true if @move_data[7] == 0
    # ターゲット座標計算
    if @target_battler == nil
    @target_x = @move_x * 100
    @target_x = (Graphics.width - @move_x) * 100 if @mirror
    @target_y = @move_y * 100
    else
    move_data_set
    end
    # ターゲットに到達するまでの時間を 算
    @move_time = distanse_calculation(@move_time, @target_x, @target_y)
    # 円軌道計算
    orbit
    # バトラーのウエイト設定
    @battler.sv.wait = @move_time - 1 if @move_data[10][0]
    @move_horming = @move_data[12]
    end
    #--------------------------------------------------------------------------
    # ● 速度を時間に変換
    #--------------------------------------------------------------------------
    def distanse_calculation(time, target_x, target_y)
    return time if !@distanse_move
    distanse_x = @position_x - @target_x
    distanse_x = @target_x - @position_x if @target_x > @position_x
    distanse_y = @position_y - @target_y
    distanse_y = @target_y - @position_y if @target_y > @position_y
    distanse = [distanse_x, distanse_y].max
    return distanse / (time * 100) + 1
    end
    #--------------------------------------------------------------------------
    # ● 移動目標の更新
    #--------------------------------------------------------------------------
    def move_data_set
    return if @target_battler == nil
    position = N03.get_targets_position(@target_battler, true, @anime_position)
    @target_x = position[0] + @move_x
    @target_y = position[1] - position[2] + @move_y
    end
    #--------------------------------------------------------------------------
    # ● 開始位置を計算
    #--------------------------------------------------------------------------
    def start_position
    starter = [@battler.sv.m_a_starter.shift]
    starter = N03.get_targets(@move_data[2], @battler) if @move_data[2] < 0
    position = [0, 0]
    position = N03.get_targets_position(starter, true, @anime_position) if starter != nil
    @position_x = position[0] + @move_data[4][0] * 100
    @position_y = position[1] + position[2] + @move_data[4][1] * 100
    @position_z = @position_y
    end
    #--------------------------------------------------------------------------
    # ● 円軌道計算
    #--------------------------------------------------------------------------
    def orbit
    orbit_data = @move_data[8].dup
    orbit_data[0] *= 100
    orbit_data[1] *= 100
    orbit_d = []
    for i in 0...@move_time / 2
    @orbit[i] = orbit_data[0]
    orbit_data[0] /= 2
    orbit_d[i] = orbit_data[1]
    orbit_data[1] /= 2
    end
    @orbit = @orbit + orbit_d.reverse!
    @orbit.reverse!
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def update
    update_hit_anime if @anime_time != 0
    update_move if @move_time != 0
    update_weapon_move if @weapon_data != []
    update_position
    update_color
    self.visible = @battler.sv.weapon_visible
    super
    end
    #--------------------------------------------------------------------------
    # ● ヒット時の戦闘アニメ
    #--------------------------------------------------------------------------
    def update_hit_anime
    @anime_time -= 1
    @action_end = true if @anime_time == 0
    end
    #--------------------------------------------------------------------------
    # ● 移動の更新
    #--------------------------------------------------------------------------
    def update_move
    move_data_set if @move_horming && !@hit_position
    through_set(@move_time, @target_x, @target_y) if @move_time == 1 && !@hit_position
    @o += @orbit[@move_time - 1] if @orbit[@move_time - 1] != nil
    @position_x = (@position_x * (@move_time - 1) + @target_x) / @move_time
    @position_y = (@position_y * (@move_time - 1) + @target_y) / @move_time + @o
    reset_position
    set_animation(@move_data[1][0]) if @loop && !animation?
    @move_time -= 1
    return if @move_time != 0
    @action_end = true if !@action_end_cancel
    end
    #--------------------------------------------------------------------------
    # ● 武器の動きを更新
    #--------------------------------------------------------------------------
    def update_weapon_move
    pattern = update_pattern
    set_battler_position if @move_time == 0 && !@action_end_cancel
    @real_x = @position_x / 100 + @weapon_move_data[pattern][0] / 100
    @real_y = @position_y / 100 + @weapon_move_data[pattern][1] / 100
    @real_zoom_x = @weapon_zoom_data[pattern][0]
    @real_zoom_y = @weapon_zoom_data[pattern][1]
    self.angle = @weapon_angle_data[pattern]
    self.src_rect.set(@weapon_width * pattern, 0, @weapon_width, @weapon_height) if @weapon_data[1] == 2
    end
    #--------------------------------------------------------------------------
    # ● パターンを更新
    #--------------------------------------------------------------------------
    def update_pattern
    return @battler.sv.pattern_w if @count == nil
    @count -= 1
    return @pattern if @count != 0
    @count = @max_count
    @pattern += 1
    if !@repeat && @pattern == @max_pattern
    @pattern = @max_pattern - 1
    elsif @pattern == @max_pattern
    @pattern = 0
    end
    return @pattern
    end
    #--------------------------------------------------------------------------
    # ● 座標を更新
    #--------------------------------------------------------------------------
    def update_position
    self.x = (@real_x - $sv_camera.x) * $sv_camera.convert / 1000
    self.y = (@real_y - $sv_camera.y) * $sv_camera.convert / 1000
    self.x += $sv_camera.sx / 100 unless @battler.sv.h != 0 && @weapon_data != []
    self.y += $sv_camera.sy / 100 unless @battler.sv.h != 0 && @weapon_data != []
    self.z = @battler.sv.z + @z_plus - 10
    self.zoom_x = @real_zoom_x * $sv_camera.zoom
    self.zoom_y = @real_zoom_y * $sv_camera.zoom
    self.opacity = @battler.sv.opacity if @battler.sv.opacity_data[4]
    end
    #--------------------------------------------------------------------------
    # ● 貫通の処理
    #--------------------------------------------------------------------------
    def through_set(time, target_x, target_y)
    @hit_anime_id = N03.get_attack_anime_id(@move_data[1][1], @battler)
    @battler.sv.wait = N03.get_anime_time(@hit_anime_id) if @move_data[10][1]
    moving_x = (target_x / 100 - @position_x / 100) / time
    moving_y = (target_y / 100 - @position_y / 100) / time
    goal_x = $sv_camera.max_left - 100 if moving_x < 0
    goal_x = Graphics.width + $sv_camera.max_right + 100 if moving_x > 0
    goal_y = $sv_camera.max_top - 100 if moving_y < 0
    goal_y = Graphics.height + $sv_camera.max_bottom + 100 if moving_y > 0
    if goal_x == nil && goal_y == nil
    time = 0
    reset_position
    else
    time = move_calculation(moving_x, moving_y, goal_x, goal_y)
    end
    target_x = @position_x + moving_x * time * 100
    target_y = @position_y + moving_y * time * 100
    @pre_data = [time, target_x, target_y]
    @battler.sv.m_a_data.push([@move_data[11], @target_battler, @index, @auto_through_flag, []])
    @action_end_cancel = true
    @hit_position = [@real_x, @real_y, self.z]
    end
    #--------------------------------------------------------------------------
    # ● 到達時間試算
    #--------------------------------------------------------------------------
    def move_calculation(moving_x, moving_y, goal_x, goal_y)
    move_x = @position_x / 100
    move_y = @position_y / 100
    time = 0
    loop do
    move_x += moving_x
    move_y += moving_y
    time += 1
    return time if moving_x < 0 && move_x < goal_x
    return time if moving_x > 0 && move_x > goal_x
    return time if moving_y < 0 && move_y < goal_y
    return time if moving_y > 0 && move_y > goal_y
    end
    end
    #--------------------------------------------------------------------------
    # ● ミス時に消える処理から貫通処理に 換
    #--------------------------------------------------------------------------
    def through_change
    @action_end_cancel = false
    @through = true
    @move_time = @pre_data[0]
    @target_x = @pre_data[1]
    @target_y = @pre_data[2]
    @pre_data = nil
    end
    #--------------------------------------------------------------------------
    # ● SE とフラッシュのタイミング処理
    #--------------------------------------------------------------------------
    def animation_process_timing(timing)
    return if !@timing_targets
    se_flag = true
    se_flag = @se_flag if @se_flag != nil
    for target in @timing_targets
    target.sv.timing.push([se_flag, timing.dup])
    se_flag = false if @animation.position == 3
    end
    end
    #--------------------------------------------------------------------------
    # ● 色調の更新
    #--------------------------------------------------------------------------
    def update_color
    return if @battler.sv.color == []
    self.color.set(@battler.sv.color[0], @battler.sv.color[1], @battler.sv.color[2], @battler.sv.color[3])
    end
    #--------------------------------------------------------------------------
    # ● 解放
    #--------------------------------------------------------------------------
    def dispose
    super
    self.bitmap.dispose if self.bitmap != nil
    end
    end

    #================================================= =============================
    # ■ Sprite_Battle_Picture
    #------------------------------------------------------------------------------
    #  ピクチャ表示用のスプライトです
    #================================================= =============================
    class Sprite_Battle_Picture < Sprite
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数 
    #--------------------------------------------------------------------------
    attr_accessor :action_end # 終了フラグ
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    def initialize(viewport = nil)
    super(viewport)
    @action_end = false
    self.ox = 0
    end
    #--------------------------------------------------------------------------
    # ● セット
    #--------------------------------------------------------------------------
    def set(battler)
    @battler = battler
    @data = @battler.sv.effect_data.shift
    @time = @data[4]
    @mirror = $sv_camera.mirror
    @mirror = false if !@data[8]
    self.opacity = @data[6][0]
    @s_x = @data[2][0] if @data[2] != []
    @s_x = Graphics.width - @data[2][0] if @data[2] != [] && @mirror
    @s_y = @data[2][1] if @data[2] != []
    @e_x = @data[3][0] if @data[3] != []
    @e_x = Graphics.width - @data[3][0] if @data[3] != [] && @mirror
    @e_y = @data[3][1] if @data[3] != []
    @s_x = self.x if @data[2] == []
    @s_y = self.y if @data[2] == []
    @e_x = self.x if @data[3] == []
    @e_y = self.y if @data[3] == []
    self.x = @s_x
    self.y = @s_y
    return @action_end = true if @time == 0
    @move_x = (@e_x * 1.0 - @s_x) / @time
    @move_y = (@e_y * 1.0 - @s_y) / @time
    self.z = @data[5]
    return set_plane(battler) if @data[7] != []
    self.bitmap = Cache.picture(@data[9]) if !bitmap or @data[9] != ""
    return @action_end = true if !bitmap
    self.mirror = @mirror
    self.ox = self.bitmap.width if @mirror
    end
    #--------------------------------------------------------------------------
    # ● プレーン移行
    #--------------------------------------------------------------------------
    def set_plane(battler)
    @viewport = Viewport.new(@data[2][0],@data[2][1],@data[7][0],@data[7][1]) if !@viewport
    viewport = @viewport
    @plane = Plane.new(viewport) if !@plane
    @plane.bitmap = Cache.picture(@data[9]) if !@plane.bitmap or @data[9] != ""
    return @action_end = true if !@plane.bitmap
    @plane.ox = @data[7][0]
    @plane.oy = @data[7][1]
    @plane.opacity = @data[6][0]
    @move_x = @remain_move[0] if @data[2] == @data[3]
    @move_y = @remain_move[1] if @data[2] == @data[3]
    @remain_move = [@move_x, @move_y]
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def update
    @action_end = true if !@battler.sv.picture
    return if @time == 0
    return if @action_end
    @time -= 1
    return plane_update if @plane
    super
    self.x += @move_x
    self.y += @move_y
    self.opacity += @data[6][1]
    return if @time != 1
    self.x = @e_x
    self.y = @e_y
    @time = 0
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def plane_update
    @plane.ox += @move_x
    @plane.oy += @move_y
    @plane.opacity += @data[6][1]
    @time = @data[4] if @time == 0
    end
    #--------------------------------------------------------------------------
    # ● 解放
    #--------------------------------------------------------------------------
    def dispose
    bitmap.dispose if bitmap
    @plane.dispose if @plane
    @viewport.dispose if @viewport
    super
    end
    end

    #================================================= =============================
    # ■ Sprite_Back_Picture
    #------------------------------------------------------------------------------
    #  周期ピクチャ用のスプライトです
    #================================================= =============================
    class Sprite_Back_Picture < Plane
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数 
    #--------------------------------------------------------------------------
    attr_accessor :action_end # 終了フラグ
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    def initialize(viewport = nil, index)
    super(viewport)
    @index = index
    @real_x = 0
    @real_y = 0
    @real_opacity = 0
    @move_x = 0
    @move_y = 0
    @move_opacity = 0
    @time = 0
    @switche = 0
    @action_end = false
    end
    #--------------------------------------------------------------------------
    # ● セットアップ
    #--------------------------------------------------------------------------
    def setup(data)
    self.bitmap = Cache.picture(data[9])
    self.z = data[6]
    @switche = data[1]
    mirror = $sv_camera.mirror
    mirror = false if !data[8]
    @move_x = data[3][0]
    @move_x *= -1 if mirror
    @move_y = data[3][1]
    @time = data[4]
    @time = -1 if @time == 0
    @real_opacity = (data[5][0] + 1) * 100
    @move_opacity = data[5][1]
    @start_opacity = data[5][0]
    @shake_ok = data[7]
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def update
    update_picture if @time != 0
    self.ox = $sv_camera.x - @real_x
    self.oy = $sv_camera.y - @real_y
    if @shake_ok
    self.ox -= $sv_camera.sx / 100
    self.oy -= $sv_camera.sy / 100
    end
    self.ox *= $sv_camera.zoom
    self.oy *= $sv_camera.zoom
    self.zoom_x = @zoom_x * $sv_camera.zoom
    self.zoom_y = @zoom_y * $sv_camera.zoom
    self.opacity = @real_opacity / 100
    @move_opacity *= -1 if self.opacity == 255 or self.opacity <= @start_opacity
    @switche
    @action_end = true if @switche > 0 && !$game_switches[@switche]
    @action_end = true if @switche < 0 && !$sv_camera.switches[@switche.abs]
    end
    #--------------------------------------------------------------------------
    # ● ピクチャの更新
    #--------------------------------------------------------------------------
    def update_picture
    @real_x += @move_x / 100
    @real_y += @move_y / 100
    @real_x = 0 if @real_x >= self.bitmap.width or @real_x <= -self.bitmap.width
    @real_y = 0 if @real_y >= self.bitmap.height or @real_y <= -self.bitmap.height
    @zoom_x = 1
    @zoom_y = 1
    @real_opacity += @move_opacity
    @time -= 1
    @time = -1 if @time < -100
    end
    end

    #================================================= =============================
    # ■ Sprite_Back_Picture
    #------------------------------------------------------------------------------
    #  ダメージ表示のスプライトです。
    #================================================= =============================
    class Sprite_Damage < Sprite
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数 
    #--------------------------------------------------------------------------
    attr_reader :action_end # POP終了フラグ
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    def initialize(viewport = nil, battler)
    super(viewport)
    @battler = battler
    @time = 0
    return @action_end = true if !@battler
    @direction = -1
    @direction *= -1 if @battler.actor?
    @direction *= -1 if $sv_camera.mirror
    set_state
    set_damage
    update
    end
    #--------------------------------------------------------------------------
    # ● ステート表示
    #--------------------------------------------------------------------------
    def set_state
    return if !N03::STATE_POP
    states = @battler.result.added_state_objects
    states.delete($data_states[@battler.death_state_id]) if @battler.result.hp_damage != 0
    return if states == []
    return if @battler.sv.add_state == @battler.result.added_state_objects
    @battler.sv.add_state = states.dup
    @st = []
    @st_base = []
    for i in 0...states.size
    @st[i] = Sprite.new
    bitmap_state(@st[i], states[i])
    @st_base[i] = []
    @st_base[i][0] = @direction * (-20 + 5 * i) + @battler.sv.x / 100
    @st_base[i][1] = -40 - @state_height * i + (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.oy_adjust)/ 100
    @st[i].z = 1000 + i
    @st[i].opacity = 0
    end
    @time = @pop_time = 80
    end
    #--------------------------------------------------------------------------
    # ● ステート画像
    #--------------------------------------------------------------------------
    def bitmap_state(state, state_object)
    name = state_object.name
    state.bitmap = Cache.system("Iconset").dup
    state.src_rect.set(state_object.icon_index % 16 * 24, state_object.icon_index / 16 * 24, 24, 24)
    @state_height = 24
    end
    #--------------------------------------------------------------------------
    # ● ダメージ表示
    #--------------------------------------------------------------------------
    def hit_count
    for i in 0...@battler.sv.hit.size
    if @battler.sv.hit[i] == nil
    @hit = i
    return @battler.sv.hit[i] = @hit
    end
    end
    @hit = @battler.sv.hit.size
    @battler.sv.hit.push(@hit)
    end
    #--------------------------------------------------------------------------
    # ● ダメージ表示
    #--------------------------------------------------------------------------
    def set_damage
    return @action_end = true if !N03:AMAGE_POP
    damage = @battler.result.hp_damage if @battler.result.hp_damage != 0
    damage = @battler.result.hp_drain if @battler.result.hp_drain != 0
    damage = @battler.result.mp_damage if @battler.result.mp_damage != 0
    damage = @battler.result.mp_drain if @battler.result.mp_drain != 0
    damage = @battler.result.tp_damage if @battler.result.tp_damage != 0
    if !damage or damage == 0
    @action_end = true if @st == nil
    return # ステートだけPOPする設定を考慮して@a ction_endは返さない
    end
    hit_count
    #@hit = @battler.sv.hit
    #@battler.sv.hit += 1 if damage != 0
    file = N03:AMAGE_PLUS if damage > 0
    file = N03:AMAGE_MINUS if damage < 0
    add_file = N03:AMAGE_MP if @battler.result.mp_damage != 0
    add_file = N03:AMAGE_TP if @battler.result.tp_damage != 0
    adjust_x = N03:AMAGE_ADJUST
    @num = []
    @num_base = []
    damage = damage.abs
    max_num = damage.to_s.size
    max_num += 1 if add_file != nil
    for i in 0...max_num
    @num[i] = Sprite.new
    if add_file != nil && i == max_num - 1
    @num[i].bitmap = Cache.system(add_file)
    cw = (damage % (10 * 10 ** i))/(10 ** i)
    sw = 0 if sw == nil
    else
    @num[i].bitmap = Cache.system(file)
    cw = (damage % (10 * 10 ** i))/(10 ** i)
    sw = @num[i].bitmap.width / 10
    @num[i].src_rect.set(cw * sw, 0, sw, @num[i].bitmap.height)
    end
    @num_base[i] = []
    @num_base[i][0] = (sw + adjust_x) * i * -1 + (@battler.sv.x / 100)
    @num_base[i][1] = -(@num[i].bitmap.height / 3) - i * 2 - @hit * 2 + (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.oy_adjust)/ 100
    @num_base[i][0] -= @num[i].bitmap.width / 2 - adjust_x if add_file != nil && i == max_num - 1
    @num[i].z = 1000 + i + @hit * 10
    end
    @time = @pop_time = 80
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def update
    return if @time == 0
    for i in 0...@st.size do update_state_move(@st[i], i) end if @st != nil
    for i in 0...@num.size do update_num_move(@num[i], i) end if @num != nil
    @time -= 1
    @action_end = true if @time == 0
    end
    #--------------------------------------------------------------------------
    # ● ステート画像の更新
    #--------------------------------------------------------------------------
    def update_state_move(state, index)
    min = @pop_time - index * 2
    case @time
    when min-15..min
    @st_base[index][0] += @direction
    state.opacity += 25
    when min-80..min-50
    @st_base[index][0] += @direction
    state.opacity -= 25
    end
    state.x = (@st_base[index][0] - $sv_camera.x) * $sv_camera.zoom
    state.y = (@st_base[index][1] - $sv_camera.y) * $sv_camera.zoom
    end
    #--------------------------------------------------------------------------
    # ● 数値の更新
    #--------------------------------------------------------------------------
    def update_num_move(num, index)
    min = @pop_time - index * 2
    case @time
    when min-1..min
    @num_base[index][0] += @direction * @hit
    @num_base[index][1] -= 5 + @hit * 2
    when min-3..min-2
    @num_base[index][0] += @direction * @hit
    @num_base[index][1] -= 4 + @hit * 2
    when min-6..min-4
    @num_base[index][0] += @direction
    @num_base[index][1] -= 3 + @hit * 2
    when min-14..min-7
    @num_base[index][0] += @direction
    @num_base[index][1] += 2
    when min-17..min-15
    @num_base[index][1] -= 2 + @hit * 2
    when min-23..min-18
    @num_base[index][1] += 1
    when min-27..min-24
    @num_base[index][1] -= 1
    when min-30..min-28
    @num_base[index][1] += 1
    when min-33..min-31
    @num_base[index][1] -= 1
    when min-36..min-34
    @num_base[index][1] += 1
    end
    num.x = (@num_base[index][0] - $sv_camera.x) * $sv_camera.zoom
    num.y = (@num_base[index][1] - $sv_camera.y) * $sv_camera.zoom
    num.opacity = 256 - (12 - @time) * 32
    num.visible = false if @time == 0
    end
    #--------------------------------------------------------------------------
    # ● 解放
    #--------------------------------------------------------------------------
    def dispose
    @battler.sv.hit[@hit] = nil if @hit
    bitmap.dispose if bitmap
    for i in 0...@num.size do @num[i].dispose end if @num != nil
    for i in 0...@st.size do @st[i].dispose end if @st != nil
    super
    end
    end

    #================================================= =============================
    # ■ Window_Skill_name
    #------------------------------------------------------------------------------
    #  スキル名を表示するウィンドウで 。
    #================================================= =============================
    class Window_Skill_name < Window_Base
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    def initialize(text)
    super(0, 0, Graphics.width, line_height + standard_padding * 2)
    draw_text(4, 0, Graphics.width - 64, line_height,text, 1)
    end
    end

    #================================================= =============================
    # ■ Spriteset_Sideview
    #------------------------------------------------------------------------------
    #  サイドビュー独自のスプライトを とめたクラスです。
    #================================================= =============================
    class Spriteset_Sideview
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    def initialize(viewport)
    @viewport = viewport
    @weapons = []
    @pictures = []
    @back_pic = []
    @damage = []
    $sv_camera.setup
    N03.camera(nil, N03::BATTLE_CAMERA["ターン開始前"].dup)
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def update
    update_battler_data
    update_damage
    update_pictures
    update_back_pic
    update_weapons
    end
    #--------------------------------------------------------------------------
    # ● バトラーデータの更新
    #--------------------------------------------------------------------------
    def update_battler_data
    for battler in $game_party.battle_members + $game_troop.members
    weapon_end(battler) if battler.sv.weapon_end
    next if battler.sv.effect_data == []
    for effect_data in battler.sv.effect_data do set_effects(battler, effect_data) end
    end
    end
    #--------------------------------------------------------------------------
    # ● ダメージ画像の更新
    #--------------------------------------------------------------------------
    def update_damage
    for i in 0...@damage.size
    next if @damage[i] == nil
    @damage[i].update if @damage[i] != nil
    next if !@damage[i].action_end
    @damage[i].dispose
    @damage[i] = nil
    end
    end
    #--------------------------------------------------------------------------
    # ● ピクチャアクションの更新
    #--------------------------------------------------------------------------
    def update_pictures
    for i in 0...@pictures.size
    next if @pictures[i] == nil
    @pictures[i].update if @pictures[i] != nil
    next if !@pictures[i].action_end
    @pictures[i].dispose
    @pictures[i] = nil
    end
    end
    #--------------------------------------------------------------------------
    # ● 周期ピクチャの更新
    #--------------------------------------------------------------------------
    def update_back_pic
    set_back_pic if $sv_camera.program_picture != []
    for i in 0...@back_pic.size
    next if @back_pic[i] == nil
    @back_pic[i].update if @back_pic[i] != nil
    next if !@back_pic[i].action_end
    @back_pic[i].dispose
    @back_pic[i] = nil
    end
    end
    #--------------------------------------------------------------------------
    # ● 武器アクションの更新
    #--------------------------------------------------------------------------
    def update_weapons
    for i in 0...@weapons.size
    next if @weapons[i] == nil
    @weapons[i].update if @weapons[i] != nil
    next if !@weapons[i].action_end
    @weapons[i].dispose
    @weapons[i] = nil
    end
    end
    #--------------------------------------------------------------------------
    # ● ダメージ実行
    #--------------------------------------------------------------------------
    def set_damage_pop(target)
    for i in 0...@damage.size
    next if @damage[i] != nil
    return @damage[i] = Sprite_Damage.new(@viewport, target)
    end
    @damage.push(Sprite_Damage.new(@viewport, target))
    end
    #--------------------------------------------------------------------------
    # ● 周期ピクチャ実行
    #--------------------------------------------------------------------------
    def set_back_pic
    for data in $sv_camera.program_picture
    if @back_pic[data[2]] != nil
    @back_pic[data[2]].dispose
    @back_pic[data[2]] = nil
    end
    @back_pic[data[2]] = Sprite_Back_Picture.new(@viewport, data[2])
    @back_pic[data[2]].setup(data)
    end
    $sv_camera.program_picture = []
    end
    #--------------------------------------------------------------------------
    # ● エフェクト開始
    #--------------------------------------------------------------------------
    def set_effects(battler, effect_data)
    case effect_data[0]
    when "pic" ; set_pictures(battler, effect_data)
    when "wp" ; set_weapons(battler, true)
    when "m_a" ; set_weapons(battler, false)
    end
    end
    #--------------------------------------------------------------------------
    # ● ピクチャアクション実行
    #--------------------------------------------------------------------------
    def set_pictures(battler, effect_data)
    @pictures[effect_data[1]] = Sprite_Battle_Picture.new if @pictures[effect_data[1]] == nil
    @pictures[effect_data[1]].set(battler)
    end
    #--------------------------------------------------------------------------
    # ● 武器アクション実行
    #--------------------------------------------------------------------------
    def set_weapons(battler, weapon_flag, test = true)
    for i in 0...@weapons.size
    next if @weapons[i] != nil
    @weapons[i] = Sprite_Weapon.new(@viewport, i, battler)
    battler.sv.weapon_index.push(i) if weapon_flag
    return i
    end
    @weapons.push(Sprite_Weapon.new(@viewport, @weapons.size, battler))
    battler.sv.weapon_index.push(@weapons.size - 1) if weapon_flag
    return @weapons.size - 1
    end
    #--------------------------------------------------------------------------
    # ● バトラーの武器アクション終了
    #--------------------------------------------------------------------------
    def weapon_end(battler)
    battler.sv.weapon_end = false
    for index in battler.sv.weapon_index
    weapon_index = battler.sv.weapon_index.shift
    @weapons[weapon_index].dispose if @weapons[weapon_index] != nil
    @weapons[weapon_index] = nil
    end
    battler.sv.weapon_index.compact!
    end
    #--------------------------------------------------------------------------
    # ● ヒット時の戦闘アニメ実行
    #--------------------------------------------------------------------------
    def set_hit_animation(battler, weapon_index, hit_targets, miss)
    weapon = @weapons[weapon_index]
    for target in hit_targets
    next @weapons[@hit_index].timing_battler_set(target) if @hit_index != nil
    @hit_index = set_weapons(battler, false, false)
    @weapons[@hit_index].set_hit_animation(weapon.hit_position, weapon.hit_anime_id, target)
    end
    @hit_index = nil
    if !weapon.through && !miss
    @weapons[weapon_index].dispose
    @weapons[weapon_index] = nil
    else
    @weapons[weapon_index].through_change
    end
    end
    #--------------------------------------------------------------------------
    # ● サイドビューデータの初期化
    #--------------------------------------------------------------------------
    def reset_sideview
    $sv_camera.reset
    for member in $game_troop.members + $game_party.battle_members do member.sv.reset end
    end
    #--------------------------------------------------------------------------
    # ● 解放
    #--------------------------------------------------------------------------
    def dispose
    dispose_effects(@weapons)
    dispose_effects(@pictures)
    dispose_effects(@back_pic)
    dispose_effects(@damage)
    reset_sideview
    end
    #--------------------------------------------------------------------------
    # ● エフェクト画像の解放
    #--------------------------------------------------------------------------
    def dispose_effects(effects)
    for i in 0...effects.size
    effects[i].dispose if effects[i] != nil
    effects[i] = nil
    end
    end
    end


    #================================================= =============================
    # ■ Sprite_Battle_Back
    #------------------------------------------------------------------------------
    #  戦闘背景用のスプライトです。
    #================================================= =============================
    class Sprite_Battle_Back < Plane
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    def initialize(viewport = nil, index, battleback_name)
    super(viewport)
    @index = index
    if @index == 1
    data = N03::FLOOR1_DATA[battleback_name]
    data = N03::FLOOR1_DATA["全Battlebacks1"] if data == nil
    elsif @index == 2
    data = N03::FLOOR2_DATA[battleback_name]
    data = N03::FLOOR2_DATA["全Battlebacks2"] if data == nil
    end
    data = data.dup
    @adjust_position = data[0]
    @zoom_x = data[1][0] / 100.0
    @zoom_y = data[1][1] / 100.0
    @shake_on = data[2]
    $game_switches[data[3]] = true if data[3] > 0
    $sv_camera.switches[data[3].abs] = true if data[3] < 0
    reset_scroll
    reset_back_data(battleback_name)
    end
    #--------------------------------------------------------------------------
    # ● 背景スクロールを初期化
    #--------------------------------------------------------------------------
    def reset_scroll
    @scroll_x = 0
    @scroll_y = 0
    @move_x = 0
    @move_y = 0
    end
    #--------------------------------------------------------------------------
    # ● 背景データを初期化
    #--------------------------------------------------------------------------
    def reset_back_data(battleback_name)
    @back_data = []
    @active_data = ["scroll",0, @move_x, @move_y, false, battleback_name,""]
    start_back_data(@active_data)
    end
    #--------------------------------------------------------------------------
    # ● 背景画像のセッティング
    #--------------------------------------------------------------------------
    def set_graphics(new_bitmap)
    self.bitmap = new_bitmap
    @base_x = (self.bitmap.width * @zoom_x - Graphics.width) / 2 + @adjust_position[0]
    @base_y = (self.bitmap.height * @zoom_y - Graphics.height) / 2 + @adjust_position[1]
    # 限界座標を取得
    max_top = 0
    max_bottom = self.bitmap.height * @zoom_y - Graphics.height
    max_left = 0
    max_right = self.bitmap.width * @zoom_x - Graphics.width
    exist = true
    exist = false if self.bitmap.height == 32 && self.bitmap.width == 32
    $sv_camera.setting(@index, [max_top, max_bottom, max_left, max_right, @base_x, @base_y,exist])
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def update
    return if !bitmap
    update_back_data
    update_scroll unless @move_x == 0 && @move_y == 0
    update_color
    update_position
    update_back_adjust if @bt_back != nil
    create_back_adjust if @bt_back == nil && !@active_data[10] && @scroll_x == 0 && @scroll_y == 0
    end
    #--------------------------------------------------------------------------
    # ● 背景データを更新
    #--------------------------------------------------------------------------
    def update_back_data
    delete = true if @active_data[1] > 0 && !$game_switches[@active_data[1]]
    delete = true if @active_data[1] < 0 && !$sv_camera.switches[@active_data[1].abs]
    return if !delete
    for i in 0...@back_data.size
    @back_data[i] = nil if @back_data[i][1] > 0 && !$game_switches[@back_data[i][1]]
    @back_data[i] = nil if @back_data[i][1] < 0 && !$sv_camera.switches[@back_data[i][1].abs]
    end
    @back_data.compact!
    next_back_data
    end
    #--------------------------------------------------------------------------
    # ● 次の背景データをセット
    #--------------------------------------------------------------------------
    def next_back_data
    @back_data.delete(@active_data[11]) if @active_data[11] != nil
    @back_data.push(@active_data[11]) if @active_data[11] != nil
    @active_data = nil
    data = @back_data.pop
    @back_data = [@active_data] if @back_data.size == 0
    start_back_data(data)
    end
    #--------------------------------------------------------------------------
    # ● 背景データを実行
    #--------------------------------------------------------------------------
    def start_back_data(data)
    return if back_data_remain(data)
    bt_back_dispose
    pre_active_data = @active_data
    @active_data[8] = [@back_name, @move_x, @move_y, @scroll_x, @scroll_y] if @active_data != nil
    @back_data.push(@active_data) if @active_data != nil
    @active_data = data.dup
    @active_data[5] = @back_name if @active_data[5] == ""
    @active_data[9] = set_back_adjust if @active_data[9] == nil
    back_data_scroll_on if @active_data[8] == nil && @active_data[9][0] == false
    set_remain_back_data if @active_data[8] != nil
    create_back(@active_data[5]) if @active_data[9][0] == false
    create_back_adjust if @active_data[10]
    @active_data[11] = pre_active_data if pre_active_data && @active_data[7] == false
    end
    #--------------------------------------------------------------------------
    # ● 背景データの保留
    #--------------------------------------------------------------------------
    def back_data_remain(data)
    remain = false
    remain = true if data[6] != "" && @active_data != nil && @active_data[9] != nil && @active_data[9][0] != false
    remain = true if @active_data != nil && @active_data[7] == false
    return remain if !remain
    @remain = true
    @back_data.push(data)
    return remain
    end
    #--------------------------------------------------------------------------
    # ● 背景変更補正データをセット
    #--------------------------------------------------------------------------
    def set_back_adjust
    bt_adjust = []
    sign = -1
    if @active_data[6] == ""
    reset_scroll if @active_data[3][0] == 0 && @active_data[3][1] == 0
    bt_adjust = [false,false,0,0]
    return bt_adjust
    elsif @move_x != 0 or @active_data[3][0] != 0
    sign = 1 if @move_x < 0
    bt_adjust[0] = [self.bitmap.width * @zoom_x * sign, 0]
    bt_adjust[1] = [self.bitmap.width * @zoom_x * sign * 2, 0]
    elsif @move_y != 0 or @active_data[3][1] != 0
    sign = 1 if @move_y < 0
    bt_adjust[0] = [0, self.bitmap.height * @zoom_y * sign]
    bt_adjust[1] = [0, self.bitmap.height * @zoom_y * sign * 2]
    else
    reset_scroll if @active_data[3][0] == 0 && @active_data[3][1] == 0
    bt_adjust = [false,false,0,0]
    return bt_adjust
    end
    bt_adjust[2] = [bt_adjust[0][0], bt_adjust[0][1]]
    return bt_adjust
    end
    #--------------------------------------------------------------------------
    # ● 背景スクロールデータを実行
    #--------------------------------------------------------------------------
    def back_data_scroll_on
    mirror = $sv_camera.mirror
    mirror = false if !@active_data[4]
    @move_x = @active_data[3][0]
    @move_x *= -1 if mirror
    @move_y = @active_data[3][1]
    end
    #--------------------------------------------------------------------------
    # ● 保持している背景データを実行
    #--------------------------------------------------------------------------
    def set_remain_back_data
    return back_data_scroll_on if @move_x != 0 or @move_y != 0
    create_back(@active_data[8][0])
    @move_x = @active_data[8][1]
    @move_y = @active_data[8][2]
    @scroll_x = @active_data[8][3]
    @scroll_y = @active_data[8][4]
    end
    #--------------------------------------------------------------------------
    # ● 背景画像の作成
    #--------------------------------------------------------------------------
    def create_back(back_name)
    return if back_name == @back_name or back_name == ""
    self.bitmap = Cache.battleback1(back_name) if @index == 1
    self.bitmap = Cache.battleback2(back_name) if @index == 2
    @back_name = back_name
    end
    #--------------------------------------------------------------------------
    # ● 背景変更補正画像の作成
    #--------------------------------------------------------------------------
    def create_back_adjust
    return if @active_data[9][0] == false
    @active_data[10] = true
    mirror = $sv_camera.mirror
    mirror = false if !@active_data[4]
    @bt_back = []
    @bt_back[0] = Sprite.new(viewport)
    @bt_back[0].bitmap = Cache.battleback1(@active_data[6]) if @index == 1
    @bt_back[0].bitmap = Cache.battleback2(@active_data[6]) if @index == 2
    @bt_back[0].mirror = mirror
    @bt_back[1] = Sprite.new(viewport)
    @bt_back[1].bitmap = Cache.battleback1(@active_data[5]) if @index == 1
    @bt_back[1].bitmap = Cache.battleback2(@active_data[5]) if @index == 2
    @bt_back[1].mirror = mirror
    end
    #--------------------------------------------------------------------------
    # ● 背景スクロールの更新
    #--------------------------------------------------------------------------
    def update_scroll
    @scroll_x += @move_x
    @scroll_y += @move_y
    @scroll_x = 0 if @scroll_x / 100 >= self.bitmap.width * @zoom_x or @scroll_x / 100 <= -self.bitmap.width * @zoom_x
    @scroll_y = 0 if @scroll_y / 100 >= self.bitmap.height * @zoom_y or @scroll_y / 100 <= -self.bitmap.height * @zoom_y
    end
    #--------------------------------------------------------------------------
    # ● 色調変更の更新
    #--------------------------------------------------------------------------
    def update_color
    color_set if $sv_camera.color_set[@index] != nil
    return if @color_data == nil
    @color_data[4] -= 1
    if @color_data[4] == 0 && @color_data[5] != 0
    @color_data[4] = @color_data[5]
    @color_data[5] = 0
    @color_data[6] = [0,0,0,0]
    elsif @color_data[4] == 0
    @remain_color_data = @color_data
    return @color_data = nil
    end
    for i in 0..3
    @color_data[i] = (@color_data[i] * (@color_data[4] - 1) + @color_data[6][i]) / @color_data[4]
    end
    self.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3])
    end
    #--------------------------------------------------------------------------
    # ● 座標の更新
    #--------------------------------------------------------------------------
    def update_position
    self.ox = $sv_camera.x + @base_x - @scroll_x / 100
    self.oy = $sv_camera.y + @base_y - @scroll_y / 100
    self.ox -= $sv_camera.sx / 100 if @shake_on
    self.oy -= $sv_camera.sy / 100 if @shake_on
    self.zoom_x = @zoom_x * $sv_camera.zoom
    self.zoom_y = @zoom_y * $sv_camera.zoom
    self.ox *= $sv_camera.zoom
    self.oy *= $sv_camera.zoom
    self.z = @index * 10
    end
    #--------------------------------------------------------------------------
    # ● 背景変更補正画像を更新
    #--------------------------------------------------------------------------
    def update_back_adjust
    @active_data[9][0][0] = 0 if @scroll_x == 0
    @active_data[9][0][1] = 0 if @scroll_y == 0
    @active_data[9][1][0] -= @active_data[9][2][0] if @scroll_x == 0
    @active_data[9][1][1] -= @active_data[9][2][1] if @scroll_y == 0
    for i in 0...@bt_back.size
    @bt_back[i].x = -self.ox + @active_data[9][i][0] * $sv_camera.zoom
    @bt_back[i].y = -self.oy + @active_data[9][i][1] * $sv_camera.zoom
    @bt_back[i].zoom_x = self.zoom_x
    @bt_back[i].zoom_y = self.zoom_y
    @bt_back[i].z = self.z + 1
    @bt_back[i].color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
    end
    back_data_scroll_on if @active_data[9][0][0] == 0 && @active_data[9][0][1] == 0
    return unless @active_data[9][1][0] == 0 && @active_data[9][1][1] == 0
    bt_back_dispose
    create_back(@active_data[5])
    @active_data[9][0] = false
    next_back_data if @remain && @back_data.size != 1
    @remain = false
    end
    #--------------------------------------------------------------------------
    # ● 色調変更
    #--------------------------------------------------------------------------
    def color_set
    set = $sv_camera.color_set[@index]
    $sv_camera.color_set[@index] = nil
    set[4] = 1 if set[4] == 0
    @remain_color_data = [0,0,0,0] if @remain_color_data == nil
    @color_data = @remain_color_data
    @color_data[4] = set[4]
    @color_data[5] = set[5]
    @color_data[6] = set
    end
    #--------------------------------------------------------------------------
    # ● 背景変更補正画像の解放
    #--------------------------------------------------------------------------
    def bt_back_dispose
    for i in 0...@bt_back.size do @bt_back[i].dispose end if @bt_back != nil
    @bt_back = nil
    end
    #--------------------------------------------------------------------------
    # ● 解放
    #--------------------------------------------------------------------------
    def dispose
    bitmap.dispose if bitmap
    bt_back_dispose
    super
    end
    end

    #================================================= =============================
    # ■ Battle_Camera
    #------------------------------------------------------------------------------
    #  戦闘カメラやバトルプログラムを うクラスです。
    #================================================= =============================
    class Battle_Camera
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数 
    #--------------------------------------------------------------------------
    attr_reader :sx # シェイクX座標
    attr_reader :sy # シェイクY座標
    attr_reader :max_top # 上限界座標
    attr_reader :max_bottom # 下限界座標
    attr_reader :max_left # 左限界座標
    attr_reader :max_right # 右限界座標
    attr_accessor :switches # サイドビュー専用スイッチ
    attr_accessor :color_set # 色調変更データ
    attr_accessor :wait # 戦闘シーンの強制ウエイト
    attr_accessor :win_wait # 戦闘勝利前のウエイト
    attr_accessor :mirror # 画面反転フラグ
    attr_accessor rogram_scroll # バトルプログラム 背景の自動スクロール
    attr_accessor rogram_picture # バトルプログラム 周期ピクチャ
    attr_accessor :event # コモンイベント呼び出し
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    def initialize
    @switches = []
    @max_data = []
    @color_set = []
    @wait = 0
    @win_wait = false
    @mirror = false
    @event = false
    setup
    end
    #--------------------------------------------------------------------------
    # ● カメラX座標
    #--------------------------------------------------------------------------
    def x
    return @x / 100
    end
    #--------------------------------------------------------------------------
    # ● カメラY座標
    #--------------------------------------------------------------------------
    def y
    return @y / 100
    end
    #--------------------------------------------------------------------------
    # ● ズーム率
    #--------------------------------------------------------------------------
    def zoom
    return @zoom * 0.001
    end
    #--------------------------------------------------------------------------
    # ● ズーム率による座標変換
    #--------------------------------------------------------------------------
    def convert
    return @zoom
    end
    #--------------------------------------------------------------------------
    # ● カメラセットアップ
    #--------------------------------------------------------------------------
    def setup
    @x = 0
    @y = 0
    @sx = 0
    @sy = 0
    @zoom = 1000
    @time = 0
    @shake_time = 0
    program_setup
    end
    #--------------------------------------------------------------------------
    # ● カメラ初期化
    #--------------------------------------------------------------------------
    def reset
    @switches = []
    @max_data = []
    @color_set = []
    @wait = 0
    @win_wait = false
    @mirror = false
    program_setup(false)
    end
    #--------------------------------------------------------------------------
    # ● バトルプログラムのセットアップ
    #--------------------------------------------------------------------------
    def program_setup(check = true)
    @played_program = []
    @program_switch = []
    @program_sound = []
    @program_scroll = []
    @program_se = []
    @program_shake = []
    @program_color = []
    @program_picture = []
    @program_base = N03::BATTLE_PROGRAM.values.dup
    program_check if check
    end
    #--------------------------------------------------------------------------
    # ● バトルプログラムのチェック
    #--------------------------------------------------------------------------
    def program_check
    for data in @program_base
    if program_start?(data) && !@played_program.include?(data)
    @played_program.push(data.dup)
    @program_scroll.push(data.dup) if data[0] == "scroll"
    @program_picture.push(data.dup) if data[0] == "kpic"
    start_sound(data.dup) if data[0] == "sound"
    start_program_switch(data.dup) if data[0] == "switch"
    start_program_se(data.dup) if data[0] == "keep_se"
    start_program_shake(data.dup) if data[0] == "keep_sk"
    start_program_color(data.dup) if data[0] == "keep_c"
    else
    @played_program.delete(data) if !program_start?(data)
    @program_scroll.delete(data) if data[0] == "scroll"
    @program_picture.delete(data) if data[0] == "kpic"
    @program_switch.delete(data) if data[0] == "switch"
    @program_sound.delete(data) if data[0] == "sound"
    @program_se.delete(data) if data[0] == "keep_se"
    @program_shake.delete(data) if data[0] == "keep_sk"
    @program_color.delete(data) if data[0] == "keep_c"
    end
    end
    end
    #--------------------------------------------------------------------------
    # ● バトルプログラムの開始
    #--------------------------------------------------------------------------
    def program_start?(data)
    start = false
    start = true if $game_switches[data[1].abs] && data[1] > 0
    start = true if @switches[data[1].abs] && data[1] < 0
    return start
    end
    #--------------------------------------------------------------------------
    # ● バトルプログラム スイッチ操作の開始
    #--------------------------------------------------------------------------
    def start_program_switch(data)
    data[4] = data[4] + rand(data[5] + 1)
    data[4] = 1 if data[4] <= 0
    @program_switch.push(data)
    end
    #--------------------------------------------------------------------------
    # ● スイッチ操作の更新
    #--------------------------------------------------------------------------
    def update_program_switch
    for data in @program_switch
    data[4] -= 1
    next @program_switch.delete(data) if data[1] > 0 && !$game_switches[data[1]]
    next @program_switch.delete(data) if data[1] < 0 && !@switches[data[1].abs]
    next if data[4] != 0
    for id in data[2]
    $game_switches[id] = true if id > 0
    @switches[id.abs] = true if id < 0
    end
    for id in data[3]
    $game_switches[id] = false if id > 0
    @switches[id.abs] = false if id < 0
    end
    @program_switch.delete(data)
    program_check
    end
    end
    #--------------------------------------------------------------------------
    # ● バトルプログラム BGM/BGSの開始
    #--------------------------------------------------------------------------
    def start_sound(data)
    @program_sound.push(data)
    name = data[5]
    case data[2]
    when "se"
    Audio.se_play("Audio/SE/" + name, data[4], data[3])
    when "bgm"
    name = RPG::BGM.last.name if data[5] == ""
    Audio.bgm_play("Audio/BGM/" + name, data[4], data[3])
    when "bgs"
    name = RPG::BGS.last.name if data[5] == ""
    Audio.bgs_play("Audio/BGS/" + name, data[4], data[3])
    end
    end
    #--------------------------------------------------------------------------
    # ● バトルプログラム 周期SEの開始
    #--------------------------------------------------------------------------
    def start_program_se(data)
    data[3] = [data[2], data[3]]
    data[2] = data[3][0] + rand(data[3][1] + 1)
    @program_se.push(data)
    Audio.se_play("Audio/SE/" + data[7], data[5], data[4]) if data[6]
    end
    #--------------------------------------------------------------------------
    # ● 周期SEの更新
    #--------------------------------------------------------------------------
    def update_program_se
    for data in @program_se
    data[2] -= 1
    next @program_se.delete(data) if data[1] > 0 && !$game_switches[data[1]]
    next @program_se.delete(data) if data[1] < 0 && !@switches[data[1].abs]
    next if data[2] != 0
    Audio.se_play("Audio/SE/" + data[7], data[5], data[4])
    data[2] = data[3][0] + rand(data[3][1] + 1)
    end
    end
    #--------------------------------------------------------------------------
    # ● バトルプログラム 周期シェイクの開始
    #--------------------------------------------------------------------------
    def start_program_shake(data)
    data[3] = [data[2], data[3]]
    data[2] = data[3][0] + rand(data[3][1] + 1)
    @program_shake.push(data)
    shake(data[4], data[5], data[6]) if data[7]
    end
    #--------------------------------------------------------------------------
    # ● 周期シェイクの更新
    #--------------------------------------------------------------------------
    def update_program_shake
    for data in @program_shake
    data[2] -= 1
    next @program_shake.delete(data) if data[1] > 0 && !$game_switches[data[1]]
    next @program_shake.delete(data) if data[1] < 0 && !@switches[data[1].abs]
    next if data[2] != 0
    shake(data[4], data[5], data[6])
    data[2] = data[3][0] + rand(data[3][1] + 1)
    end
    end
    #--------------------------------------------------------------------------
    # ● バトルプログラム 周期色調変更の開始
    #--------------------------------------------------------------------------
    def start_program_color(data)
    data[3] = [data[2], data[3]]
    data[2] = data[3][0] + rand(data[3][1] + 1)
    data[7] = true if data[4] == 0 or data[4] == 4
    case data[4]
    when 1 ;data[4] = $game_troop.members
    when 2 ;data[4] = $game_party.battle_members
    when 3,4 ;data[4] = $game_troop.members + $game_party.battle_members
    else ;data[4] = []
    end
    @program_color.push(data)
    return if !data[6]
    for target in data[4] do target.sv.color_set = data[5] end if data[4] != []
    @color_set[1] = data[5] if data[7]
    @color_set[2] = data[5] if data[7]
    end
    #--------------------------------------------------------------------------
    # ● 周期色調変更の更新
    #--------------------------------------------------------------------------
    def update_program_color
    for data in @program_color
    data[2] -= 1
    next @program_color.delete(data) if data[1] > 0 && !$game_switches[data[1]]
    next @program_color.delete(data) if data[1] < 0 && !@switches[data[1].abs]
    next if data[2] != 0
    for target in data[4] do target.sv.color_set = data[5] end if data[4] != []
    @color_set[1] = data[5] if data[7]
    @color_set[2] = data[5] if data[7]
    data[2] = data[3][0] + rand(data[3][1] + 1)
    end
    end
    #--------------------------------------------------------------------------
    # ● トランジション実行
    #--------------------------------------------------------------------------
    def perform_transition(data)
    Graphics.transition(data[2], "Graphics/Pictures/" + data[3], data[1])
    end
    #--------------------------------------------------------------------------
    # ● 背景からカメラの限界値を取得 data = [max_top, max_bottom, max_left, max_right]
    #--------------------------------------------------------------------------
    def setting(index, data)
    @max_data[index - 1] = data
    return if index != 2
    setup
    # カメラの中心座標
    @center_x = (Graphics.width / 2 + N03::CAMERA_POSITION[0]) * 100
    @center_y = (Graphics.height / 2 + N03::CAMERA_POSITION[1]) * 100
    # 上下左右の移動限界距離
    @max_top = [@max_data[0][5], @max_data[1][5]].min * -1
    @max_bottom = [@max_data[0][1], @max_data[1][1]].min + @max_top
    @max_left = [@max_data[0][4], @max_data[1][4]].min * -1
    @max_right = [@max_data[0][3], @max_data[1][3]].min + @max_left
    exist_data = @max_data[0] if !@max_data[1][6]
    exist_data = @max_data[1] if !@max_data[0][6]
    @max_top = exist_data[5] * -1 if exist_data != nil
    @max_bottom = exist_data[1] + @max_top if exist_data != nil
    @max_left = exist_data[4] * -1 if exist_data != nil
    @max_right = exist_data[3] + @max_left if exist_data != nil
    @max_top = @max_bottom = @max_left = @max_right = 0 if !@max_data[1][6] && !@max_data[0][6]
    @max_width = @max_right - @max_left + Graphics.width
    @max_height = @max_bottom - @max_top + Graphics.height
    # ズームアウト限界値
    max_zoom_x = 100 * Graphics.width / @max_width
    max_zoom_y = 100 * Graphics.height / @max_height
    @max_zoom_out = [max_zoom_x, max_zoom_y].max
    end
    #--------------------------------------------------------------------------
    # ● カメラ移動
    #--------------------------------------------------------------------------
    def move(target_x, target_y, zoom, time, screen = true)
    # 戦闘背景以上のサイズまでズームア トしないよう調整
    @target_zoom = [zoom * 0.01, @max_zoom_out * 0.01].max
    target_x *= -1 if screen && @mirror
    # ズーム分の中心座標補正
    if screen && @target_zoom != 1
    target_x = target_x + @center_x
    target_y = target_y + @center_y
    end
    adjust_x = @center_x * (@target_zoom - 1) / (@target_zoom ** 2 - @target_zoom)
    adjust_y = @center_y * (@target_zoom - 1) / (@target_zoom ** 2 - @target_zoom)
    adjust_x = 0 if adjust_x.nan?
    adjust_y = 0 if adjust_y.nan?
    adjust_x = @center_x if !screen && adjust_x == 0
    adjust_y = @center_y if !screen && adjust_y == 0
    @target_x = target_x - adjust_x.to_i
    @target_y = target_y - adjust_y.to_i
    @target_zoom = (@target_zoom * 1000).to_i
    @zoom = @zoom.to_i
    limit_test
    # 時間0の場合は即実行
    return @time = time.abs if time != 0
    @time = 1
    update
    end
    #--------------------------------------------------------------------------
    # ● 限界座標の試算
    #--------------------------------------------------------------------------
    def limit_test
    new_width = @max_width * @target_zoom / 1000
    new_height = @max_height * @target_zoom / 1000
    new_max_right = @max_right - (@max_width - new_width)
    new_max_bottom = @max_bottom - (@max_height - new_height)
    # 画面の移動先が限界の場合、限界座 をセット
    if @target_x < @max_left * 100
    @target_x = @max_left * 100
    end
    if @target_x > new_max_right * 100
    @target_x = new_max_right * 100
    end
    if @target_y < @max_top * 100
    @target_y = @max_top * 100
    end
    if @target_y > new_max_bottom * 100
    @target_y = new_max_bottom * 100
    end
    end
    #--------------------------------------------------------------------------
    # ● 画面のシェイク
    #--------------------------------------------------------------------------
    def shake(power, speed, time)
    @shake_x = power[0] * 100
    @shake_y = power[1] * 100
    @power_time_base = @power_time = speed
    @shake_time = time
    update_shake
    end
    #--------------------------------------------------------------------------
    # ● シェイクの更新
    #--------------------------------------------------------------------------
    def update_shake
    @sx = (@sx * (@power_time - 1) + @shake_x) / @power_time
    @sy = (@sy * (@power_time - 1) + @shake_y) / @power_time
    @power_time -= 1
    @shake_time -= 1
    return @sx = @sy = 0 if @shake_time == 0
    return if @power_time != 0
    @power_time = @power_time_base
    @shake_x = @shake_x * -4 / 5
    @shake_y = @shake_y * -4 / 5
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def update
    update_shake if @shake_time != 0
    update_program
    return if @time == 0
    @x = (@x * (@time - 1) + @target_x) / @time
    @y = (@y * (@time - 1) + @target_y) / @time
    @zoom = (@zoom * (@time - 1) + @target_zoom) / @time
    @time -= 1
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def update_program
    update_program_switch if @program_switch != []
    update_program_se if @program_se != []
    update_program_shake if @program_shake != []
    update_program_color if @program_color != []
    end
    end

    #================================================= =============================
    # ■ Scene_Battle
    #------------------------------------------------------------------------------
    #  バトル画面の処理を行うクラスで 。
    #================================================= =============================
    class Scene_Battle < Scene_Base
    #--------------------------------------------------------------------------
    # ● フレーム更新(基本)
    #--------------------------------------------------------------------------
    alias update_basic_scene_battle_n03 update_basic
    def update_basic
    update_basic_scene_battle_n03
    $sv_camera.update
    $sv_camera.wait = N03::TURN_END_WAIT + 1 if $sv_camera.win_wait
    camera_wait
    end
    #--------------------------------------------------------------------------
    # ● カメラウェイト
    #--------------------------------------------------------------------------
    def camera_wait
    process_event if $sv_camera.event
    $sv_camera.event = false if $sv_camera.event
    while $sv_camera.wait != 0
    Graphics.update
    Input.update
    update_all_windows
    $game_timer.update
    $game_troop.update
    $sv_camera.update
    @spriteset.update
    update_info_viewport
    update_message_open
    $sv_camera.wait -= 1 if $sv_camera.wait > 0
    $sv_camera.wait = 1 if $sv_camera.wait == 0 && @spriteset.effect?
    BattleManager.victory if $sv_camera.win_wait && $sv_camera.wait == 0
    end
    end
    #--------------------------------------------------------------------------
    # ● カメラウェイトのセット
    #--------------------------------------------------------------------------
    def set_camera_wait(time)
    $sv_camera.wait = time
    camera_wait
    end
    #--------------------------------------------------------------------------
    # ● エフェクト実行が終わるまでウェイ ★再定義
    #--------------------------------------------------------------------------
    def wait_for_effect
    end
    #--------------------------------------------------------------------------
    # ● ターン開始
    #--------------------------------------------------------------------------
    alias turn_start_scene_battle_n03 turn_start
    def turn_start
    turn_start_scene_battle_n03
    N03.camera(nil, N03::BATTLE_CAMERA["ターン開始後"].dup)
    end
    #--------------------------------------------------------------------------
    # ● ターン終了
    #--------------------------------------------------------------------------
    alias turn_end_scene_battle_n03 turn_end
    def turn_end
    turn_end_scene_battle_n03
    for member in $game_troop.members + $game_party.members
    N03.set_damage(member, member.sv.result_damage[0],member.sv.result_damage[1])
    member.sv.result_damage = [0,0]
    @spriteset.set_damage_pop(member) if member.result.hp_damage != 0 or member.result.mp_damage != 0
    end
    set_camera_wait(N03::TURN_END_WAIT)
    N03.camera(nil, N03::BATTLE_CAMERA["ターン開始前"].dup) if $game_party.inputable?
    @log_window.clear
    end
    #--------------------------------------------------------------------------
    # ● スキル/アイテムの使用 ★再定義
    #--------------------------------------------------------------------------
    def use_item
    item = @subject.current_action.item
    display_item(item)
    @subject.use_item(item)
    refresh_status
    @targets = @subject.current_action.make_targets.compact
    @targets = [@subject] if @targets.size == 0
    set_substitute(item)
    for time in item.repeats.times do play_sideview(@targets, item) end
    end_reaction(item)
    display_end_item
    end
    #--------------------------------------------------------------------------
    # ● スキル/アイテム名の表示
    #--------------------------------------------------------------------------
    def display_item(item)
    return @log_window.display_use_item(@subject, item) if N03::BATTLE_LOG
    @log_window.off
    @skill_name_window = Window_Skill_name.new(item.name) unless N03::NO_DISPLAY_SKILL_ID.include?(item.id) && item.is_a?(RPG::Skill)
    end
    #--------------------------------------------------------------------------
    # ● スキル/アイテム名の表示終了
    #--------------------------------------------------------------------------
    def display_end_item
    @skill_name_window.dispose if @skill_name_window != nil
    @skill_name_window = nil
    set_camera_wait(N03::ACTION_END_WAIT) if @subject.sv.derivation_skill_id == 0
    @log_window.clear if N03::BATTLE_LOG
    end
    #--------------------------------------------------------------------------
    # ● 反撃/魔法反射/身代わり処理
    #--------------------------------------------------------------------------
    def end_reaction(item)
    end_substitute if @substitute != nil
    set_reflection(item) if @reflection_data != nil
    set_counter_attack if @counter_attacker != nil
    end
    #--------------------------------------------------------------------------
    # ● 反撃の発動 ★再定義
    #--------------------------------------------------------------------------
    def invoke_counter_attack(target, item)
    return if @subject.sv.counter_id != 0
    @counter_attacker = [] if @counter_attacker == nil
    return apply_item_effects(apply_substitute(target, item), item) if !target.movable?
    @log_window.add_text(sprintf(Vocab::CounterAttack, target.name)) if N03::BATTLE_LOG
    target.sv.counter_id = target.sv.counter_skill_id
    @counter_attacker.push(target)
    end
    #--------------------------------------------------------------------------
    # ● 魔法反射の発動 ★再定義
    #--------------------------------------------------------------------------
    def invoke_magic_reflection(target, item)
    return if @subject.sv.reflection_id != 0
    @log_window.add_text(sprintf(Vocab::MagicReflectio n, target.name)) if N03::BATTLE_LOG
    target.sv.reflection_id = target.sv.reflection_anime_id
    end
    #--------------------------------------------------------------------------
    # ● 身代わりの適用 ★再定義
    #--------------------------------------------------------------------------
    def apply_substitute(target, item)
    return target if @substitute == nil
    return target if !check_substitute(target, item)
    return @substitute
    end
    #--------------------------------------------------------------------------
    # ● 身代わりセット
    #--------------------------------------------------------------------------
    def set_substitute(item)
    @substitute = N03.get_enemy_unit(@subject).substitute_battler
    return if @substitute == nil
    s_targets = []
    for i in 0...@targets.size
    next if @targets[i] == @substitute
    next if !check_substitute(@targets[i], item)
    @log_window.add_text(sprintf(Vocab::Substitute, @substitute.name, @targets[i].name))
    @targets[i].sv.start_action(@targets[i].sv.substitute_receiver_start_action)
    s_targets.push(@targets[i])
    @targets[i] = @substitute
    end
    return @substitute = nil if s_targets == []
    @substitute.sv.set_target(s_targets)
    @substitute.sv.start_action(@substitute.sv.substit ute_start_action)
    end
    #--------------------------------------------------------------------------
    # ● 身代わり終了
    #--------------------------------------------------------------------------
    def end_substitute
    for member in @substitute.sv.target_battler
    member.sv.start_action(member.sv.substitute_receiv er_end_action)
    end
    @substitute.sv.start_action(@substitute.sv.substit ute_end_action)
    @substitute = nil
    end
    #--------------------------------------------------------------------------
    # ● 反撃
    #--------------------------------------------------------------------------
    def set_counter_attack
    pre_subject = @subject
    for attacker in @counter_attacker
    @subject = attacker
    item = $data_skills[attacker.sv.counter_skill_id]
    play_sideview([pre_subject], item)
    end
    # 同一カウンター者を考慮してカウン ーIDの初期化はアクション後に実行
    for attacker in @counter_attacker do attacker.sv.counter_id = 0 end
    @subject = pre_subject
    @counter_attacker = nil
    end
    #--------------------------------------------------------------------------
    # ● 魔法反射
    #--------------------------------------------------------------------------
    def set_reflection(item)
    @log_window.back_to(1)
    for data in @reflection_data
    @subject.sv.damage_action(@subject, item)
    N03.set_damage_anime_data([@subject], @subject, data)
    apply_item_effects(@subject, item)
    @spriteset.set_damage_pop(@subject)
    end
    set_camera_wait(N03.get_anime_time(@reflection_dat a[0][0]))
    @reflection_data = nil
    end
    #--------------------------------------------------------------------------
    # ● サイドビューアクション実行
    #--------------------------------------------------------------------------
    def play_sideview(targets, item)
    @subject.sv.set_target(targets)
    return if @subject.sv.attack_action(item) == nil
    return if !@subject.movable?
    return if item.scope != 9 && item.scope != 10 && !N03.targets_alive?(targets)
    @subject.sv.start_action(@subject.sv.attack_action (item))
    @subject.sv.unshift_action(@subject.sv.flash_actio n) if @subject.flash_flg
    @subject.sv.active = true
    @subject.sv.command_action = false
    loop do
    update_basic
    data = @subject.sv.play_data
    @targets = N03.s_targets(@subject) if data[0] == "second_targets_set"
    N03.targets_set(@subject) if data[0] == "targets_set"
    @immortal = N03.immortaling if data[0] == "no_collapse" && !N03.dead_attack?(@subject, item)
    @immortal = N03.unimmortaling if data[0] == "collapse"
    next set_move_anime(item) if @subject.sv.m_a_data != []
    set_damage(item) if @subject.sv.set_damage
    break N03.derived_skill(@subject) if @subject.sv.derivation_skill_id != 0
    break if @subject.sv.action_end or @subject.hidden?
    end
    @immortal = N03.unimmortaling if @immortal
    end
    #--------------------------------------------------------------------------
    # ● ダメージの実行
    #--------------------------------------------------------------------------
    def set_damage(item)
    targets = @targets
    targets = [@subject.sv.individual_targets[0]] if @subject.sv.individual_targets.size != 0
    for target in targets do damage_anime(targets.dup, target, item) end
    @subject.sv.set_damage = false
    @subject.sv.damage_anime_data = []
    end
    #--------------------------------------------------------------------------
    # ● ダメージ戦闘アニメ処理
    #--------------------------------------------------------------------------
    def damage_anime(targets, target, item)
    @log_window.back_to(1) if @log_window.line_number == 5
    return if item.scope != 9 && item.scope != 10 && target.dead?
    @miss = false
    invoke_item(target,item)
    if target.result.missed
    target.sv.miss_action(@subject, item)
    return @miss = true
    elsif target.result.evaded or target.sv.counter_id != 0
    target.sv.evasion_action(@subject, item)
    return @miss = true
    elsif target.sv.reflection_id != 0
    N03.set_damage_anime_data(targets, target, [target.sv.reflection_id, false, false, true])
    target.sv.reflection_id = 0
    @reflection_data = [] if @reflection_data == nil
    return @reflection_data.push([N03.get_attack_anime_id(-3, @subject), false, false, true])
    end
    target.sv.damage_action(@subject, item)
    N03.set_damage(@subject, -target.result.hp_drain, -target.result.mp_drain) if target != @subject
    @spriteset.set_damage_pop(target)
    @spriteset.set_damage_pop(@subject) if target != @subject && @subject.result.hp_damage != 0 or @subject.result.mp_damage != 0
    N03.set_damage_anime_data(targets, target, @subject.sv.damage_anime_data) if @subject.sv.damage_anime_data != []
    end
    #--------------------------------------------------------------------------
    # ● 飛ばしアニメ処理
    #--------------------------------------------------------------------------
    def set_move_anime(item)
    for data in @subject.sv.m_a_data
    @subject.sv.damage_anime_data = data[4]
    hit_targets = []
    for target in data[1]
    damage_anime(data[1], target, item) if data[0]
    hit_targets.push(target) if !@miss
    end
    @miss = false if !data[3]
    @spriteset.set_hit_animation(@subject, data[2], hit_targets, @miss)
    end
    @subject.sv.set_damage = false
    @subject.sv.m_a_data = []
    end
    end

    #================================================= =============================
    # ■ DataManager
    #------------------------------------------------------------------------------
    #  データベースとゲームオブジェク を管理するモジュールです。
    #================================================= =============================
    module DataManager
    #--------------------------------------------------------------------------
    # ● 各種ゲームオブジェクトの作成 ★再定義
    #--------------------------------------------------------------------------
    def self.create_game_objects
    $game_temp = Game_Temp.new
    $game_system = Game_System.new
    $game_timer = Game_Timer.new
    $game_message = Game_Message.new
    $game_switches = Game_Switches.new
    $game_variables = Game_Variables.new
    $game_self_switches = Game_SelfSwitches.new
    $game_actors = Game_Actors.new
    $game_party = Game_Party.new
    $game_troop = Game_Troop.new
    $game_map = Game_Map.new
    $game_player = Game_Player.new
    $sv_camera = Battle_Camera.new
    end
    end

    #================================================= =============================
    # ■ BattleManager
    #------------------------------------------------------------------------------
    #  戦闘の進行を管理するモジュール す。
    #================================================= =============================
    module BattleManager
    #--------------------------------------------------------------------------
    # ● エンカウント時の処理 ★再定義
    #--------------------------------------------------------------------------
    def self.on_encounter
    @preemptive = (rand < rate_preemptive)
    @surprise = (rand < rate_surprise && !@preemptive)
    $sv_camera.mirror = @surprise if N03::BACK_ATTACK
    end
    #--------------------------------------------------------------------------
    # ● 勝利の処理 ★再定義
    #--------------------------------------------------------------------------
    def self.process_victory
    $sv_camera.win_wait = true
    end
    #--------------------------------------------------------------------------
    # ● 勝利
    #--------------------------------------------------------------------------
    def self.victory
    $sv_camera.win_wait = false
    N03.camera(nil, N03::BATTLE_CAMERA["戦闘終了時"].dup)
    for member in $game_party.members do member.sv.start_action(member.sv.win) if member.movable? end
    play_battle_end_me
    replay_bgm_and_bgs
    $game_message.add(sprintf(Vocab::Victory, $game_party.name))
    display_exp
    gain_gold
    gain_drop_items
    gain_exp
    SceneManager.return
    battle_end(0)
    return true
    end
    #--------------------------------------------------------------------------
    # ● 逃走の処理 ★再定義
    #--------------------------------------------------------------------------
    def self.process_escape
    $game_message.add(sprintf(Vocab::EscapeStart, $game_party.name))
    success = @preemptive ? true : (rand < @escape_ratio)
    Sound.play_escape
    if success
    process_abort
    for member in $game_party.members do member.sv.start_action(member.sv.escape) if member.movable? end
    else
    @escape_ratio += 0.1
    $game_message.add('\.' + Vocab::EscapeFailure)
    $game_party.clear_actions
    for member in $game_party.members do member.sv.start_action(member.sv.escape_ng) if member.movable? end
    end
    wait_for_message
    return success
    end
    #--------------------------------------------------------------------------
    # ● 次のコマンド入力へ ★再定義
    #--------------------------------------------------------------------------
    def self.next_command
    begin
    if !actor || !actor.next_command
    $game_party.battle_members[@actor_index].sv.command_action = true
    @actor_index += 1
    if @actor_index >= $game_party.members.size
    for member in $game_party.battle_members.reverse
    break member.sv.start_action(member.sv.command_a) if member.inputable?
    end
    return false
    end
    end
    end until actor.inputable?
    actor.sv.start_action(actor.sv.command_b) if actor != nil && actor.inputable?
    if pre_actor
    pre_actor.sv.start_action(pre_actor.sv.command_a) if pre_actor != nil && pre_actor.inputable?
    end
    return true
    end
    #--------------------------------------------------------------------------
    # ● 前のコマンド入力へ ★再定義
    #--------------------------------------------------------------------------
    def self.prior_command
    begin
    if !actor || !actor.prior_command
    $game_party.battle_members[@actor_index].sv.command_action = false
    @actor_index -= 1
    if @actor_index < 0
    for member in $game_party.battle_members
    break member.sv.start_action(member.sv.command_a) if member.inputable?
    end
    return false
    end
    end
    end until actor.inputable?
    actor.make_actions if actor.inputable?
    actor.sv.start_action(actor.sv.command_b) if actor.inputable?
    after_actor.sv.start_action(after_actor.sv.command _a) if after_actor != nil && after_actor.inputable?
    return true
    end
    #--------------------------------------------------------------------------
    # ● コマンド入力前のアクターを取得
    #--------------------------------------------------------------------------
    def self.pre_actor
    return if @actor_index == 0
    $game_party.members[@actor_index - 1]
    end
    #--------------------------------------------------------------------------
    # ● コマンド入力後のアクターを取得
    #--------------------------------------------------------------------------
    def self.after_actor
    $game_party.members[@actor_index + 1]
    end
    #--------------------------------------------------------------------------
    # ● 戦闘行動者を前に追加
    #--------------------------------------------------------------------------
    def self.unshift_action_battlers(battler)
    @action_battlers.unshift(battler)
    end
    end

    #================================================= =============================
    # ■ Game_Battler
    #------------------------------------------------------------------------------
    #  スプライトや行動に関するメソッ を追加したバトラーのクラスです。
    #================================================= =============================
    class Game_Battler < Game_BattlerBase
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数
    #--------------------------------------------------------------------------
    attr_reader :sv # サイドビューデータ
    attr_accessor :flash_flg # 閃きフラグ
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    alias initialize_game_battler_n03 initialize
    def initialize
    initialize_game_battler_n03
    @sv = SideView.new(self)
    end
    #--------------------------------------------------------------------------
    # ● 現在の戦闘行動を除去
    #--------------------------------------------------------------------------
    alias remove_current_action_game_battler_n03 remove_current_action
    def remove_current_action
    return @sv.derivation_skill_id = 0 if @sv.derivation_skill_id != 0
    remove_current_action_game_battler_n03
    end
    #--------------------------------------------------------------------------
    # ● ターン終了処理
    #--------------------------------------------------------------------------
    alias on_turn_end_game_battler_n03 on_turn_end
    def on_turn_end
    on_turn_end_game_battler_n03
    @sv.add_state = []
    @sv.result_damage = [@result.hp_damage, @result.mp_damage]
    end
    #--------------------------------------------------------------------------
    # ● パラメータ条件比較 data = [種別, 数値, 判別]
    #--------------------------------------------------------------------------
    def comparison_parameter(data)
    return true if data[0][0] == 0
    kind = data[0]
    num = data[1]
    select = data[2]
    case kind
    when 1 ; par = level
    when 2 ; par = mhp
    when 3 ; par = mmp
    when 4 ; par = hp
    when 5 ; par = mp
    when 6 ; par = tp
    when 7 ; par = atk
    when 8 ; par = self.def
    when 9 ; par = mat
    when 10 ; par = mdf
    when 11 ; par = agi
    when 12 ; par = luk
    end
    if num < 0
    case kind
    when 4 ; num = mhp * num / 100
    when 5 ; num = mmp * num / 100
    when 6 ; num = max_tp * num / 100
    end
    num = num.abs
    end
    case select
    when 0 ; return par == num
    when 1 ; return par < num
    when 2 ; return par > num
    end
    end
    #--------------------------------------------------------------------------
    # ● 装備条件比較 data = [装備種別, タイプID]
    #--------------------------------------------------------------------------
    def comparison_equip(data)
    kind = data[0]
    items = weapons if kind == 0
    items = armors if kind == 1
    for item in items
    for id in data[1]
    return true if id > 0 && item.is_a?(RPG::Weapon) && item == $data_weapons[id.abs]
    return true if id > 0 && item.is_a?(RPG::Armor) && item == $data_armors[id.abs]
    return true if id < 0 && item.is_a?(RPG::Weapon) && item.wtype_id == id.abs
    return true if id < 0 && item.is_a?(RPG::Armor) && item.stype_id == id.abs
    end
    end
    return false
    end

    end
    #================================================= =============================
    # ■ Game_Actor
    #------------------------------------------------------------------------------
    #  アクターを扱うクラスです。
    #================================================= =============================
    class Game_Actor < Game_Battler
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数
    #--------------------------------------------------------------------------
    attr_reader :actor_id # ID
    #--------------------------------------------------------------------------
    # ● ID
    #--------------------------------------------------------------------------
    def id
    return @actor_id
    end
    #--------------------------------------------------------------------------
    # ● スプライトを使うか? ★再定義
    #--------------------------------------------------------------------------
    def use_sprite?
    return true
    end
    #--------------------------------------------------------------------------
    # ● ダメージ効果の実行 ★再定義
    #--------------------------------------------------------------------------
    def perform_damage_effect
    return if !N03::ACTOR_DAMAGE
    $game_troop.screen.start_shake(5, 5, 10)
    @sprite_effect_type = :blink
    Sound.play_actor_damage
    end

    end

    #================================================= =============================
    # ■ Game_Enemy
    #------------------------------------------------------------------------------
    #  敵キャラを扱うクラスです。
    #================================================= =============================
    class Game_Enemy < Game_Battler
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数
    #--------------------------------------------------------------------------
    attr_reader :enemy_id # ID
    #--------------------------------------------------------------------------
    # ● ID
    #--------------------------------------------------------------------------
    def id
    return @enemy_id
    end
    #--------------------------------------------------------------------------
    # ● レベル
    #--------------------------------------------------------------------------
    def level
    return @sv.level
    end
    #--------------------------------------------------------------------------
    # ● ダメージ効果の実行 ★再定義
    #--------------------------------------------------------------------------
    def perform_damage_effect
    return if !N03::ENEMY_DAMAGE
    @sprite_effect_type = :blink
    Sound.play_enemy_damage
    end
    #--------------------------------------------------------------------------
    # ● 武器
    #--------------------------------------------------------------------------
    def weapons
    weapon1 = $data_weapons[@sv.enemy_weapon1_id]
    weapon2 = $data_weapons[@sv.enemy_weapon2_id]
    return [weapon1, weapon2]
    end
    #--------------------------------------------------------------------------
    # ● 防具
    #--------------------------------------------------------------------------
    def armors
    return [$data_armors[@sv.enemy_shield_id]]
    end
    #--------------------------------------------------------------------------
    # ● 二刀流の判定
    #--------------------------------------------------------------------------
    def dual_wield?
    return $data_weapons[@sv.enemy_weapon2_id] != nil
    end
    #--------------------------------------------------------------------------
    # ● バトラー画像変更
    #--------------------------------------------------------------------------
    def graphics_change(battler_name)
    @battler_name = battler_name
    end
    #--------------------------------------------------------------------------
    # ● 通常攻撃 アニメーション ID の取得
    #--------------------------------------------------------------------------
    def atk_animation_id1
    return weapons[0].animation_id if weapons[0]
    return weapons[1] ? 0 : 1
    end
    #--------------------------------------------------------------------------
    # ● 通常攻撃 アニメーション ID の取得(二刀流:武器2)
    #--------------------------------------------------------------------------
    def atk_animation_id2
    return weapons[1] ? weapons[1].animation_id : 0
    end
    end

    #================================================= =============================
    # ■ Sprite_Base
    #------------------------------------------------------------------------------
    #  アニメーションの表示処理を追加 たスプライトのクラスです。
    #================================================= =============================
    class Sprite_Base < Sprite
    #--------------------------------------------------------------------------
    # ● アニメーションの座標更新 (ホーミングあり)
    #--------------------------------------------------------------------------
    def update_animation_position_horming
    return if @action_end_cancel
    ani_ox_set if @horming
    camera_zoom = $sv_camera.zoom
    camera_zoom = 1 if @move_anime
    kind = 1
    kind = -1 if @ani_mirror && !@anime_no_mirror
    cell_data = @animation.frames[@animation.frame_max - (@ani_duration + @ani_rate - 1) / @ani_rate].cell_data
    for i in 0..15
    @ani_sprites[i].x = (@ani_ox + cell_data[i, 1] * kind - $sv_camera.x) * camera_zoom if @ani_sprites[i] != nil && cell_data[i, 1] != nil
    @ani_sprites[i].y = (@ani_oy + cell_data[i, 2] - $sv_camera.y) * camera_zoom if @ani_sprites[i] != nil && cell_data[i, 2] != nil
    end
    end
    #--------------------------------------------------------------------------
    # ● アニメーション元の座標をセット
    #--------------------------------------------------------------------------
    def ani_ox_set
    if !SceneManager.scene_is?(Scene_Battle)
    @real_x = x
    @real_y = y
    end
    @ani_ox = @real_x - ox + width / 2
    @ani_oy = @real_y - oy + height / 2
    @ani_oy -= height / 2 if @animation.position == 0
    @ani_oy += height / 2 if @animation.position == 2
    end
    #--------------------------------------------------------------------------
    # ● アニメーションの更新
    #--------------------------------------------------------------------------
    alias update_animation_sprite_base_n03 update_animation
    def update_animation
    update_animation_position_horming if animation? && SceneManager.scene_is?(Scene_Battle) && @animation.position != 3
    update_animation_sprite_base_n03
    end
    #--------------------------------------------------------------------------
    # ● アニメーションの原点設定 ★再定義
    #--------------------------------------------------------------------------
    def set_animation_origin
    return ani_ox_set if @animation.position != 3
    if viewport == nil
    @ani_ox = Graphics.width / 2
    @ani_oy = Graphics.height / 2
    else
    @ani_ox = viewport.rect.width / 2
    @ani_oy = viewport.rect.height / 2
    end
    end
    #--------------------------------------------------------------------------
    # ● アニメーションスプライトの設定 ★再定義
    #--------------------------------------------------------------------------
    def animation_set_sprites(frame)
    camera_zoom = 1
    camera_zoom = $sv_camera.zoom if @anime_camera_zoom && @animation.position != 3 && SceneManager.scene_is?(Scene_Battle)
    camera_x = $sv_camera.x
    camera_y = $sv_camera.y
    camera_x = camera_y = 0 if @animation.position == 3 or !SceneManager.scene_is?(Scene_Battle)
    plus_z = 5
    plus_z = 1000 if @animation.position == 3
    plus_z = -17 if @plus_z != nil && @plus_z == false
    plus_z = -self.z + 10 if @plus_z != nil && @plus_z == false && @animation.position == 3
    cell_data = frame.cell_data
    @ani_sprites.each_with_index do |sprite, i|
    next unless sprite
    pattern = cell_data[i, 0]
    if !pattern || pattern < 0
    sprite.visible = false
    next
    end
    sprite.bitmap = pattern < 100 ? @ani_bitmap1 : @ani_bitmap2
    sprite.visible = true
    sprite.src_rect.set(pattern % 5 * 192,
    pattern % 100 / 5 * 192, 192, 192)
    if @ani_mirror && !@anime_no_mirror
    sprite.x = (@ani_ox - cell_data[i, 1] - camera_x) * camera_zoom
    sprite.y = (@ani_oy + cell_data[i, 2] - camera_y) * camera_zoom
    sprite.angle = (360 - cell_data[i, 4])
    sprite.mirror = (cell_data[i, 5] == 0)
    else
    sprite.x = (@ani_ox + cell_data[i, 1] - camera_x) * camera_zoom
    sprite.y = (@ani_oy + cell_data[i, 2] - camera_y) * camera_zoom
    sprite.angle = cell_data[i, 4]
    sprite.mirror = (cell_data[i, 5] == 1)
    end
    sprite.z = self.z + plus_z + i
    sprite.ox = 96
    sprite.oy = 96
    sprite.zoom_x = cell_data[i, 3] * camera_zoom / 100.0
    sprite.zoom_y = cell_data[i, 3] * camera_zoom/ 100.0
    sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
    sprite.blend_type = cell_data[i, 7]
    end
    end
    #--------------------------------------------------------------------------
    # ● 子スプライトフラグ
    #--------------------------------------------------------------------------
    def set(battler, horming, camera_zoom, no_mirror)
    @battler = battler
    @next = true
    self.bitmap = Bitmap.new(@battler.sv.cw, @battler.sv.ch)
    self.ox = bitmap.width / 2
    self.oy = bitmap.height
    @horming = horming
    @anime_camera_zoom = camera_zoom
    @anime_no_mirror = no_mirror
    @battler.sv.reset_anime_data
    end
    #--------------------------------------------------------------------------
    # ● 子スプライト座標セット
    #--------------------------------------------------------------------------
    def set_position(z, zoom_x, zoom_y, real_x, real_y)
    self.z = z
    self.zoom_x = zoom_x
    self.zoom_y = zoom_y
    @real_x = real_x
    @real_y = real_y
    end
    #--------------------------------------------------------------------------
    # ● 他スプライトへのタイミング処理
    #--------------------------------------------------------------------------
    def other_process_timing(timing)
    se_flag = true
    se_flag = @se_flag if @se_flag != nil
    @battler.sv.timing.push([se_flag, timing.dup])
    end
    #--------------------------------------------------------------------------
    # ● 他バトラーへのタイミング処理
    #--------------------------------------------------------------------------
    def target_battler_process_timing(timing)
    for target in @timing_targets
    target.sv.timing.push([false, timing.dup])
    end
    end
    #--------------------------------------------------------------------------
    # ● SE とフラッシュのタイミング処理
    #--------------------------------------------------------------------------
    alias animation_process_timing_sprite_base_n03 animation_process_timing
    def animation_process_timing(timing)
    target_battler_process_timing(timing) if @timing_targets && @timing_targets != []
    return other_process_timing(timing) if @next != nil
    animation_process_timing_sprite_base_n03(timing)
    end
    #--------------------------------------------------------------------------
    # ● アニメーションの解放
    #--------------------------------------------------------------------------
    alias dispose_animation_sprite_base_n03 dispose_animation
    def dispose_animation
    dispose_animation_sprite_base_n03
    end
    end


    #================================================= =============================
    # ■ Sprite_Battler
    #------------------------------------------------------------------------------
    #  バトラー表示用のスプライトです
    #================================================= =============================
    class Sprite_Battler < Sprite_Base
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数 
    #--------------------------------------------------------------------------
    attr_accessor :removing # パーティ離脱中
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    alias initialize_sprite_battler_n03 initialize
    def initialize(viewport, battler = nil)
    initialize_sprite_battler_n03(viewport, battler)
    @real_x = @real_y = 0
    update_bitmap if @battler != nil
    end
    #--------------------------------------------------------------------------
    # ● アニメーションの開始 ★再定義
    #--------------------------------------------------------------------------
    def start_animation(animation, mirror = false)
    return next_animation(animation, mirror) if animation?
    @animation = animation
    if @animation
    @horming = @battler.sv.anime_horming
    @anime_camera_zoom = @battler.sv.anime_camera_zoom
    @anime_no_mirror = @battler.sv.anime_no_mirror
    @timing_targets = @battler.sv.timing_targets
    @plus_z = @battler.sv.anime_plus_z
    @battler.sv.reset_anime_data
    @ani_mirror = mirror
    set_animation_rate
    @ani_duration = @animation.frame_max * @ani_rate + 1
    load_animation_bitmap
    make_animation_sprites
    set_animation_origin
    end
    end
    #--------------------------------------------------------------------------
    # ● 次のアニメを開始
    #--------------------------------------------------------------------------
    def next_animation(animation, mirror)
    @next_anime = [] if @next_anime == nil
    @next_anime.push(Sprite_Base.new(viewport))
    @next_anime[@next_anime.size - 1].set(battler, @battler.sv.anime_horming, @battler.sv.anime_camera_zoom, @battler.sv.anime_no_mirror)
    @next_anime[@next_anime.size - 1].set_position(self.z, self.zoom_x, self.zoom_y, @real_x, @real_y)
    @next_anime[@next_anime.size - 1].start_animation(animation, mirror)
    end
    #--------------------------------------------------------------------------
    # ● 影グラフィック作成
    #--------------------------------------------------------------------------
    def create_shadow
    reset_shadow
    return if @battler.sv.shadow == false
    @shadow = Sprite.new(viewport) if @shadow == nil
    @shadow.bitmap = Cache.character(@battler.sv.shadow)
    @shadow.ox = @shadow.bitmap.width / 2
    @shadow.oy = @shadow.bitmap.height / 2
    end
    #--------------------------------------------------------------------------
    # ● 影グラフィック初期化
    #--------------------------------------------------------------------------
    def reset_shadow
    return if @shadow == nil
    @shadow.dispose
    @shadow = nil
    end
    #--------------------------------------------------------------------------
    # ● 転送元ビットマップの更新 ★再定義
    #--------------------------------------------------------------------------
    def update_bitmap
    update_bitmap_enemy if !@battler.actor?
    update_bitmap_actor if @battler.actor?
    update_src_rect if @battler != nil
    update_color if @battler != nil
    end
    #--------------------------------------------------------------------------
    # ● 転送元ビットマップ:エネミー
    #--------------------------------------------------------------------------
    def update_bitmap_enemy
    if @battler.battler_name != @battler_name or @battler.battler_hue != @battler_hue
    @battler_name = @battler.battler_name
    @battler_hue = @battler.battler_hue
    @battler_graphic_file_index = @battler.sv.graphic_file_index
    @graphic_mirror_flag = @battler.sv.graphic_mirror_flag
    self.bitmap = Cache.battler(@battler_name + @battler_graphic_file_index, @battler_hue)
    @battler.sv.setup(self.bitmap.width, self.bitmap.height, @battler_id != @battler.id)
    create_shadow
    init_visibility
    @battler_id = @battler.id
    end
    end
    #--------------------------------------------------------------------------
    # ● 転送元ビットマップ:アクター
    #--------------------------------------------------------------------------
    def update_bitmap_actor
    if @battler.character_name != @battler_name or @battler.character_index != @battler_index
    @battler_name = @battler.character_name
    @battler_index = @battler.character_index
    @battler_graphic_file_index = @battler.sv.graphic_file_index
    @graphic_mirror_flag = @battler.sv.graphic_mirror_flag
    self.bitmap = Cache.character(@battler_name + @battler_graphic_file_index)
    @battler.sv.setup(self.bitmap.width, self.bitmap.height, @battler_id != @battler.id)
    create_shadow
    init_visibility
    @battler_id = @battler.id
    end
    end
    #--------------------------------------------------------------------------
    # ● 可視状態の初期化 ★再定義
    #--------------------------------------------------------------------------
    def init_visibility
    @battler_visible = @battler.alive?
    @battler_visible = true if @battler.sv.state(1) != "敵コラプス"
    @battler_visible = false if @battler.hidden?
    @battler.sv.opacity = 0 unless @battler_visible
    self.opacity = 0 unless @battler_visible
    self.opacity = 255 if @battler_visible
    @battler.sv.weapon_visible = @battler_visible
    end
    #--------------------------------------------------------------------------
    # ● 転送元矩形の更新
    #--------------------------------------------------------------------------
    def update_src_rect
    return if @battler.sv.collapse
    if @battler_graphic_file_index != @battler.sv.graphic_file_index
    @battler_graphic_file_index = @battler.sv.graphic_file_index
    self.bitmap = Cache.character(@battler_name + @battler_graphic_file_index) if @battler.actor?
    self.bitmap = Cache.battler(@battler_name + @battler_graphic_file_index, @battler_hue) if !@battler.actor?
    @battler.sv.set_graphics(self.bitmap.width, self.bitmap.height)
    end
    anime_off if @battler.sv.anime_off
    self.src_rect.set(@battler.sv.sx, @battler.sv.sy, @battler.sv.cw, @battler.sv.ch)
    self.opacity = @battler.sv.opacity if @battler_visible
    set_process_timing(@battler.sv.timing) if @battler && @battler.sv.timing != []
    end
    #--------------------------------------------------------------------------
    # ● 位置の更新 ★再定義
    #--------------------------------------------------------------------------
    def update_position
    @real_x = @battler.sv.x / 100
    @real_y = (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.c - @battler.sv.oy_adjust)/ 100
    self.x = @real_x - $sv_camera.x
    self.y = @real_y - $sv_camera.y
    self.z = @battler.sv.z - @battler.sv.c / 100
    if @battler.sv.h <= 0
    self.x += $sv_camera.sx / 100
    self.y += $sv_camera.sy / 100
    end
    self.x *= $sv_camera.zoom
    self.y *= $sv_camera.zoom
    end
    #--------------------------------------------------------------------------
    # ● 原点の更新 ★再定義
    #--------------------------------------------------------------------------
    def update_origin
    return if !bitmap or @battler.sv.collapse
    self.ox = @battler.sv.ox
    self.oy = @battler.sv.oy
    self.angle = @battler.sv.angle
    self.zoom_x = @battler.sv.zoom_x * $sv_camera.zoom
    self.zoom_y = @battler.sv.zoom_y * $sv_camera.zoom
    self.mirror = @battler.sv.mirror if !@graphic_mirror_flag
    self.mirror = !@battler.sv.mirror if @graphic_mirror_flag
    end
    #--------------------------------------------------------------------------
    # ● 影グラフィックの更新
    #--------------------------------------------------------------------------
    def update_shadow
    @shadow.visible = @battler.sv.shadow_visible
    @shadow.opacity = @battler.sv.opacity if @battler.sv.opacity_data[3]
    @shadow.opacity = self.opacity if !@battler.sv.opacity_data[3]
    @shadow.x = @real_x - $sv_camera.x
    @shadow.y = (@battler.sv.y - @battler.sv.c)/ 100 - $sv_camera.y
    @shadow.z = @battler.sv.z - 10
    @shadow.zoom_x = $sv_camera.zoom
    @shadow.zoom_y = $sv_camera.zoom
    @shadow.x += $sv_camera.sx / 100
    @shadow.y += $sv_camera.sy / 100
    @shadow.x *= $sv_camera.zoom
    @shadow.y *= $sv_camera.zoom
    @shadow.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
    end
    #--------------------------------------------------------------------------
    # ● ふきだしの更新
    #--------------------------------------------------------------------------
    def update_balloon
    if @battler.sv.balloon_data == [] && @balloon
    @balloon_data = []
    @balloon.dispose
    return @balloon = nil
    elsif @battler.sv.balloon_data != [] && @battler.sv.balloon_data != @balloon_data
    @balloon_data = @battler.sv.balloon_data
    @balloon = Sprite.new(self.viewport)
    @balloon.bitmap = Cache.system("Balloon")
    @balloon.zoom_x = @balloon_data[3]
    @balloon.zoom_y = @balloon_data[3]
    @balloon.ox = 32 if @battler.sv.mirror
    @balloon.oy = 16
    @balloon_count = 0
    end
    return if !@balloon
    @balloon.opacity = self.opacity
    @balloon.x = self.x
    @balloon.y = self.y - @battler.sv.ch * $sv_camera.zoom
    @balloon.z = self.z + 20
    @balloon.src_rect.set(32 + @balloon_count / @balloon_data[2] * 32, @balloon_data[1] * 32, 32, 32) if @balloon_count % @balloon_data[2] == 0
    @balloon.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
    @balloon_count += 1
    @balloon_count = 0 if @balloon_count == @balloon_data[2] * 7
    end
    #--------------------------------------------------------------------------
    # ● 色調変更の更新
    #--------------------------------------------------------------------------
    def update_color
    color_set if @battler.sv.color_set != []
    return if @color_data == nil
    @color_data[4] -= 1
    if @color_data[4] == 0 && @color_data[5] != 0
    @color_data[4] = @color_data[5]
    @color_data[5] = 0
    @color_data[6] = [0,0,0,0]
    elsif @color_data[4] == 0
    @remain_color_data = @color_data
    @battler.sv.color = @color_data.dup
    return @color_data = nil
    end
    for i in 0..3
    @color_data[i] = (@color_data[i] * (@color_data[4] - 1) + @color_data[6][i]) / @color_data[4]
    end
    @battler.sv.color = @color_data.dup
    self.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3])
    end
    #--------------------------------------------------------------------------
    # ● 残像の更新
    #--------------------------------------------------------------------------
    def update_mirage
    if @battler.sv.mirage == [] && @mirages
    @mirage_data = []
    for mirage in @mirages do mirage.dispose end
    return @mirages = nil
    elsif @battler.sv.mirage != [] && @battler.sv.mirage != @mirage_data
    @mirage_data = @battler.sv.mirage
    @mirages = []
    for i in 0...@mirage_data[1] do @mirages[i] = Sprite.new(self.viewport) end
    @mirage_count = 0
    end
    return if !@mirages
    @mirage_count += 1
    @mirage_count = 0 if @mirage_count == @mirage_data[2] * @mirages.size
    for i in 0...@mirages.size
    mirage_body(@mirages[i], @mirage_data[4]) if @mirage_count == 1 + i * @mirage_data[2]
    end
    end
    #--------------------------------------------------------------------------
    # ● 残像本体
    #--------------------------------------------------------------------------
    def mirage_body(body, opacity)
    body.bitmap = self.bitmap.dup
    body.x = self.x
    body.y = self.y
    body.ox = self.ox
    body.oy = self.oy
    body.z = self.z - 20
    body.mirror = self.mirror
    body.angle = self.angle
    body.opacity = opacity * self.opacity / 255
    body.zoom_x = self.zoom_x
    body.zoom_y = self.zoom_y
    body.src_rect.set(@battler.sv.sx, @battler.sv.sy, @battler.sv.cw, @battler.sv.ch)
    body.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
    end
    #--------------------------------------------------------------------------
    # ● 次のアニメを更新
    #--------------------------------------------------------------------------
    def update_next_anime
    return if !@next_anime
    for anime in @next_anime
    anime.update
    anime.set_position(self.z, self.zoom_x, self.zoom_y, @real_x, @real_y) if @horming
    anime.dispose if !anime.animation?
    @next_anime.delete(anime) if !anime.animation?
    end
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    alias update_sprite_battler_n03 update
    def update
    @battler.sv.update if @battler
    update_sprite_battler_n03
    update_next_anime
    update_shadow if @battler && @shadow
    update_mirage if @battler
    update_balloon if @battler
    update_remove if @battler && @removing && @battler.sv.change_up
    end
    #--------------------------------------------------------------------------
    # ● 戦闘アニメ消去
    #--------------------------------------------------------------------------
    def anime_off
    @battler.sv.anime_off = false
    dispose_animation
    for anime in @next_anime do anime.dispose_animation end if @next_anime
    end
    #--------------------------------------------------------------------------
    # ● バトラー入れ替え
    #--------------------------------------------------------------------------
    def remove
    @battler.sv.start_action(@battler.sv.remove_action )
    $sv_camera.wait = 40
    @battler.sv.add_action("eval('set_change')")
    @removing = true
    end
    #--------------------------------------------------------------------------
    # ● バトラー入れ替えの更新
    #--------------------------------------------------------------------------
    def update_remove
    @battler.sv.change_up = false
    @removing = false
    @battler = nil
    end
    #--------------------------------------------------------------------------
    # ● バトラー加入
    #--------------------------------------------------------------------------
    def join(join_battler)
    $sv_camera.wait = 30
    @battler = join_battler
    @battler_name = @battler.character_name
    @battler_index = @battler.character_index
    @battler_graphic_file_index = @battler.sv.graphic_file_index
    self.bitmap = Cache.character(@battler_name)
    @battler.sv.setup(self.bitmap.width, self.bitmap.height, true)
    create_shadow
    init_visibility
    end
    #--------------------------------------------------------------------------
    # ● 通常の設定に戻す ★再定義
    #--------------------------------------------------------------------------
    def revert_to_normal
    self.blend_type = 0
    self.opacity = 255
    end
    #--------------------------------------------------------------------------
    # ● 崩壊エフェクトの更新
    #--------------------------------------------------------------------------
    alias update_collapse_sprite_battler_n03 update_collapse
    def update_collapse
    return if @battler.sv.state(1) != "敵コラプス"
    update_collapse_sprite_battler_n03
    @battler.sv.weapon_visible = false
    end
    #--------------------------------------------------------------------------
    # ● ボス崩壊エフェクトの更新 ★再定義
    #--------------------------------------------------------------------------
    def update_boss_collapse
    @effect_duration = @battler.sv.ch if @effect_duration >= @battler.sv.ch
    alpha = @effect_duration * 120 / @battler.sv.ch
    self.ox = @battler.sv.cw / 2 + @effect_duration % 2 * 4 - 2
    self.blend_type = 1
    self.color.set(255, 255, 255, 255 - alpha)
    self.opacity = alpha
    self.src_rect.y -= 1
    Sound.play_boss_collapse2 if @effect_duration % 20 == 19
    end
    #--------------------------------------------------------------------------
    # ● 別スプライトからのタイミング処理
    #--------------------------------------------------------------------------
    def set_process_timing(timing_data)
    for data in timing_data
    set_timing(data[0],data[1])
    end
    @battler.sv.timing = []
    end
    #--------------------------------------------------------------------------
    # ● タイミング処理
    #--------------------------------------------------------------------------
    def set_timing(se_flag, data)
    @ani_rate = 4
    data.se.play if se_flag
    case data.flash_scope
    when 1 ;self.flash(data.flash_color, data.flash_duration * @ani_rate)
    when 2 ;viewport.flash(data.flash_color, data.flash_duration * @ani_rate) if viewport
    when 3 ;self.flash(nil, data.flash_duration * @ani_rate)
    end
    end
    #--------------------------------------------------------------------------
    # ● 色調変更
    #--------------------------------------------------------------------------
    def color_set
    set = @battler.sv.color_set
    @battler.sv.color_set= []
    set[4] = 1 if set[4] == 0
    @remain_color_data = [0,0,0,0] if @remain_color_data == nil
    @color_data = @remain_color_data
    @color_data[4] = set[4]
    @color_data[5] = set[5]
    @color_data[6] = set
    end
    #--------------------------------------------------------------------------
    # ● 解放
    #--------------------------------------------------------------------------
    alias dispose_sprite_battler_n03 dispose
    def dispose
    dispose_sprite_battler_n03
    @shadow.dispose if @shadow != nil
    @balloon.dispose if @balloon != nil
    for mirage in @mirages do mirage.dispose end if @mirages != nil
    for anime in @next_anime do anime.dispose end if @next_anime
    end
    end


    #================================================= =============================
    # ■ Spriteset_Battle
    #------------------------------------------------------------------------------
    #  バトル画面のスプライトをまとめ クラスです。
    #================================================= =============================
    class Spriteset_Battle
    #--------------------------------------------------------------------------
    # ● 戦闘背景(床)スプライトの作成 ★再定義
    #--------------------------------------------------------------------------
    def create_battleback1
    @back1_sprite = Sprite_Battle_Back.new(@viewport1, 1, battleback1_name)
    @back1_sprite.set_graphics(battleback1_bitmap) if battleback1_name != nil
    @back1_sprite.z = 0
    end
    #--------------------------------------------------------------------------
    # ● 戦闘背景(壁)スプライトの作成 ★再定義
    #--------------------------------------------------------------------------
    def create_battleback2
    @back2_sprite = Sprite_Battle_Back.new(@viewport1, 2, battleback2_name)
    @back2_sprite.set_graphics(battleback2_bitmap) if battleback2_name != nil
    @back2_sprite.z = 1
    end
    #--------------------------------------------------------------------------
    # ● アクタースプライトの作成 ★再定義
    #--------------------------------------------------------------------------
    def create_actors
    @actor_sprites = []
    for i in 0...$game_party.max_battle_members
    @actor_sprites[i] = Sprite_Battler.new(@viewport1, $game_party.members[i])
    end
    @effect_sprites = Spriteset_Sideview.new(@viewport1)
    end
    #--------------------------------------------------------------------------
    # ● アクタースプライトの更新 ★再定義
    #--------------------------------------------------------------------------
    def update_actors
    @actor_sprites.each_with_index do |sprite, i|
    sprite_join($game_party.members[i], sprite) if sprite.battler == nil && sprite.battler != $game_party.members[i]
    sprite.remove if sprite.battler != nil && !sprite.removing && sprite.battler != $game_party.members[i]
    sprite.update
    end
    @effect_sprites.update
    update_program
    end
    #--------------------------------------------------------------------------
    # ● メンバーを加える
    #--------------------------------------------------------------------------
    def sprite_join(member, sprite)
    for sp in @actor_sprites
    sp.update_remove if member == sp.battler && !sp.battler.sv.change_up
    end
    sprite.join(member)
    end
    #--------------------------------------------------------------------------
    # ● バトルプログラムの更新
    #--------------------------------------------------------------------------
    def update_program
    return if $sv_camera.program_scroll == []
    for data in $sv_camera.program_scroll
    @back1_sprite.start_back_data(data) if data[2] == 1
    @back2_sprite.start_back_data(data) if data[2] == 2
    end
    $sv_camera.program_scroll = []
    end
    #--------------------------------------------------------------------------
    # ● ヒット時の戦闘アニメ実行
    #--------------------------------------------------------------------------
    def set_hit_animation(battler, weapon_index, hit_targets, miss)
    @effect_sprites.set_hit_animation(battler, weapon_index, hit_targets, miss)
    end
    #--------------------------------------------------------------------------
    # ● ダメージPOP
    #--------------------------------------------------------------------------
    def set_damage_pop(target)
    @effect_sprites.set_damage_pop(target)
    end
    #--------------------------------------------------------------------------
    # ● 解放
    #--------------------------------------------------------------------------
    alias dispose_spriteset_battle_n03 dispose
    def dispose
    dispose_spriteset_battle_n03
    @effect_sprites.dispose
    end



    end


    #================================================= =============================
    # ■ Window_BattleLog
    #------------------------------------------------------------------------------
    #  戦闘の進行を実況表示するウィン ウです。
    #================================================= =============================
    class Window_BattleLog < Window_Selectable
    #--------------------------------------------------------------------------
    # ● ウェイト ★再定義
    #--------------------------------------------------------------------------
    def wait
    end
    #--------------------------------------------------------------------------
    # ● ウェイトとクリア ★再定義
    #--------------------------------------------------------------------------
    def wait_and_clear
    $sv_camera.wait = 10
    end
    #--------------------------------------------------------------------------
    # ● 行動結果の表示 ★再定義
    #--------------------------------------------------------------------------
    def display_action_results(target, item)
    if target.result.used
    last_line_number = line_number
    display_critical(target, item)
    display_damage(target, item)
    display_affected_status(target, item)
    display_failure(target, item)
    end
    off if !N03::BATTLE_LOG
    end
    #--------------------------------------------------------------------------
    # ● ウインドウ非表示
    #--------------------------------------------------------------------------
    def off
    @back_sprite.visible = self.visible = false
    end
    end
    #================================================= =============================
    # ■ Game_Interpreter
    #------------------------------------------------------------------------------
    #  イベントコマンドを実行するイン プリタです。
    #================================================= =============================
    class Game_Interpreter
    #--------------------------------------------------------------------------
    # ● スイッチの操作
    #--------------------------------------------------------------------------
    alias command_121_game_interpreter_n03 command_121
    def command_121
    command_121_game_interpreter_n03
    $sv_camera.program_check
    end
    end

  3. #843
    Бывалый Аватар для Soliд
    Информация о пользователе
    Регистрация
    24.04.2011
    Адрес
    Далеко за горами
    Сообщений
    907
    Записей в дневнике
    5
    Репутация: 32 Добавить или отнять репутацию

    По умолчанию

    Цитата Сообщение от rammsteks Посмотреть сообщение
    Версия мейкера VX Ace

    Спойлер 1:
    #================================================= =============================
    # ■ Sideview Ver100
    #------------------------------------------------------------------------------
    #  サイドビューバトラーを管理する ラスです。
    #================================================= =============================
    class SideView
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数 
    #--------------------------------------------------------------------------
    attr_accessor :x # 画面X座標
    attr_accessor :y # 画面Y座標
    attr_accessor :z # 画面Z座標
    attr_accessor :h # 高さ座標
    attr_accessor :j # ジャンプ座標
    attr_accessor :c # カーブ座標
    attr_accessor x # 横原点
    attr_accessor y # 縦原点
    attr_accessor y_adjust # 縦原点補正
    attr_accessor :angle # 回転角度
    attr_accessor :zoom_x # 横の拡大率
    attr_accessor :zoom_y # 縦の拡大率
    attr_accessor attern_w # セル横位置(矩形内)
    attr_accessor attern_h # セル縦位置(矩形内)
    attr_accessor :sx # セル横位置(画像全体)
    attr_accessor :sy # セル縦位置(画像全体)
    attr_accessor attern_type # セル更新タイプ
    attr_accessor attern_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 pacity # 透明度
    attr_accessor pacity_data # 透明度操作情報
    attr_accessor :set_damage # バトルシーンでのダメージ処理
    attr_accessor :m_a_data # アニメ飛ばし情報
    attr_accessor :m_a_starter # アニメ飛ばし開始ターゲット情報
    attr_accessor :action_end # バトルシーンでの行動終了
    attr_accessor :damage_anime_data # ダメージ戦闘アニメのデータ
    attr_accessor :anime_no_mirror # 戦闘アニメの反転禁止フラグ
    attr_accessor :anime_horming # 戦闘アニメのホーミングフラグ
    attr_accessor :anime_camera_zoom # 戦闘アニメがカメラに合わせて拡大 小するか
    attr_accessor :anime_plus_z # 戦闘アニメZ座標補正
    attr_accessor :derivation_skill_id # スキル派生ID
    attr_accessor :immortal # 不死身フラグ
    attr_accessor :mirage # 残像データ
    attr_accessor :balloon_data # ふきだしデータ
    attr_accessor :timing # 別バトラーからのタイミングデータ
    attr_accessor :timing_targets # タイミングデータを渡す別バトラー
    attr_accessor :color_set # 色調変更データ
    attr_accessor :color # 色調データ
    attr_accessor :change_up # 画像変更フラグ
    attr_accessor :hit # 被攻撃回数
    attr_accessor :add_state # 何度も付加ステートの表示を防ぐフ グ
    attr_accessor :counter_id # カウンター時のスキルID
    attr_accessor :reflection_id # 魔法反射時のアニメID
    attr_accessor :result_damage # ターン終了時のHP変動データ
    attr_accessor :active # 行動権
    attr_accessor :anime_off # 戦闘アニメ消去
    attr_accessor :command_action # コマンドアクションフラグ

    attr_accessor :base_x # 初期位置 X座標
    attr_accessor :base_y # 初期位置 Y座標
    attr_accessor :base_h # 初期位置 高さ座標
    attr_accessor :max_pattern_w # セルの横分割数
    attr_accessor :max_pattern_h # セルの縦分割数

    attr_reader :collapse # コラプスフラグ
    attr_reader icture # ピクチャ表示フラグ
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    def initialize(battler)
    @battler = battler
    reset
    end
    #--------------------------------------------------------------------------
    # ● 初期化
    #--------------------------------------------------------------------------
    def reset
    @x = 0
    @y = 0
    @z = 0
    @h = 0
    @j = 0
    @c = 0
    @jump = []
    @curve = []
    @ox = 0
    @oy = 0
    @oy_adjust = 0
    @z_plus = 0
    @move_time = 0
    @angle = 0
    @angle_time = 0
    @zoom_x = 1
    @zoom_y = 1
    @zoom_time = 0
    @pattern_w = 0
    @pattern_h = 0
    @sx = 0
    @sy = 0
    @pattern_type = 0
    @pattern_time = 0
    @pattern_rest_time = 0
    @graphic_name = ""
    @graphic_file_index = ""
    @graphic_index = 0
    @cw = 0
    @ch = 0
    @shadow_visible = false
    @weapon_visible = true

    @wait = 0
    @weapon_index = []
    @weapon_end = true
    @full_action = []
    @action = []
    @force_action = ""
    @target_battler = []
    @second_targets = []
    @individual_targets = []
    @m_a_targets = []
    @effect_data = []
    @anime_id = []
    @anime_move_id = []
    @opacity = 255
    @opacity_data = []
    @set_damage = false
    @m_a_data = []
    @m_a_starter = []
    @action_end = false
    @damage_anime_data = []
    @anime_no_mirror = false
    @anime_horming = false
    @anime_camera_zoom = false
    @anime_plus_z = true
    @derivation_skill_id = 0
    @immortal = false
    @mirage = []
    @play_data = []
    @balloon_data = []
    @picture = false
    @timing = []
    @timing_targets = []
    @color_set = []
    @color = []
    @change_up = false
    @non_motion = false
    @graphics_change = false
    @hit = []
    @add_state = []
    @collapse = false
    @counter_id = 0
    @reflection_id = 0
    @result_damage = [0,0]
    @active = false
    @anime_off = false
    @command_action = false

    @base_x = 0
    @base_y = 0
    @base_z = 0
    @base_h = 0
    @max_pattern_w = 0
    @max_pattern_h = 0
    @pattern_kind = 0
    @pattern_count = 0
    @move_time = 0
    @mirror = false
    @battler.set_graphic(@pre_change_data[0], @pre_change_data[1], @pre_change_data[2], @pre_change_data[3]) if @pre_change_data != nil
    @pre_change_data = nil
    end
    #--------------------------------------------------------------------------
    # ● セットアップ
    #--------------------------------------------------------------------------
    def setup(bitmap_width, bitmap_height, first_action_flag)
    reset if first_action_flag
    set_data
    set_base_position if !@graphics_change
    set_graphics(bitmap_width, bitmap_height)
    set_target
    setup_graphics_change if @graphics_change
    first_battler_anime_set if first_action_flag
    end
    #--------------------------------------------------------------------------
    # ● バトラーデータ取得
    #--------------------------------------------------------------------------
    def set_data
    return if @battler == nil
    if @battler.actor?
    @graphic_name = @battler.character_name
    @graphic_index = @battler.character_index
    else
    @graphic_name = @battler.battler_name
    @graphic_index = 0
    end
    @max_pattern_w = max_pattern[0]
    @max_pattern_h = max_pattern[1]
    end
    #--------------------------------------------------------------------------
    # ● ベース座標をセット data = [X軸, Y軸, H軸] moment_set…瞬間配置
    #--------------------------------------------------------------------------
    def set_base_position(moment_set = true)
    mirroring_reset
    if @battler.actor?
    data = N03::ACTOR_POSITION[@battler.index].dup
    @base_x = data[0] * 100 if !@mirror
    @base_x = (Graphics.width - data[0]) * 100 if @mirror
    else
    data = [@battler.screen_x, @battler.screen_y, 0].dup
    @base_x = data[0] * 100 if !$sv_camera.mirror
    @base_x = (Graphics.width - data[0]) * 100 if $sv_camera.mirror
    end
    @base_y = data[1] * 100
    @base_h = data[2] * 100
    @base_z = @y
    return if !moment_set
    @x = @base_x
    @y = @base_y
    @z = @base_z
    end
    #--------------------------------------------------------------------------
    # ● グラフィックデータ取得
    #--------------------------------------------------------------------------
    def set_graphics(bitmap_width, bitmap_height)
    sign = @graphic_name[/^[\!\$]./]
    if sign && sign.include?('$')
    @cw = bitmap_width / @max_pattern_w
    @ch = bitmap_height / @max_pattern_h
    elsif @max_pattern_w == 1 && @max_pattern_h == 1
    @cw = bitmap_width
    @ch = bitmap_height
    else
    @cw = bitmap_width / (@max_pattern_w * 4)
    @ch = bitmap_height / (@max_pattern_h * 2)
    end
    @ox = @cw / 2
    @oy = @ch
    @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
    @sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch
    end
    #--------------------------------------------------------------------------
    # ● ターゲットをセット
    #--------------------------------------------------------------------------
    def set_target(target = nil)
    @target_battler = target
    @target_battler = [@battler] if target == nil
    @second_targets = @target_battler
    end
    #--------------------------------------------------------------------------
    # ● 画像変更用のセットアップ
    #--------------------------------------------------------------------------
    def setup_graphics_change
    @graphics_change = false
    @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
    @sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch
    end
    #--------------------------------------------------------------------------
    # ● 戦闘開始時の待機アニメ画像データ 得
    #--------------------------------------------------------------------------
    def first_battler_anime_set
    loop do
    update
    break if @action_data == nil
    break if @action_data[0] == "motion"
    break if @action_data[0] == "move" && @action_data[8] != ""
    break if @full_action == []
    end
    start_action(first_action) if @battler.movable?
    end
    #--------------------------------------------------------------------------
    # ● アクション開始
    #--------------------------------------------------------------------------
    def start_action(kind = nil)
    return if @event_fix && $game_troop.interpreter.running?
    # ウェイト中の場合キャンセル
    return @wait -= 1 if @wait > 0 && kind == nil
    action_setup(false) if kind != nil
    set_action(kind)
    @action = kind if @action == nil
    # 行動配列が無い場合は行動終了処理 移行
    action_terminate if @action == nil
    # 次のアクション決定
    @action_data = N03::ACTION[@action]
    next_action
    end
    #--------------------------------------------------------------------------
    # ● 行動パラメータの初期化
    #--------------------------------------------------------------------------
    def action_setup(reset = true)
    @event_fix = false
    @set_damage = false
    @action_end = false
    @balloon_data = []
    @loop_act = []
    angle_reset if reset
    zoom_reset if reset
    opacity_reset if reset
    @curve = []
    @c = 0
    convert_jump
    end
    #--------------------------------------------------------------------------
    # ● 行動終了処理
    #--------------------------------------------------------------------------
    def action_terminate
    @mirage = [] if @mirage_end
    mirroring_reset
    @picture = false
    @individual_targets = []
    action_setup if @active
    action_setup(false) if !@active
    # 待機アクションへ移行
    stand_by_action if !@non_motion
    # 戦闘行動のアクティブ権を終了
    next_battler
    end
    #--------------------------------------------------------------------------
    # ● 新しいアクション内容の決定
    #--------------------------------------------------------------------------
    def set_action(kind = nil)
    full_act = N03::FULLACTION[kind]
    @full_action = full_act.dup if full_act != nil
    @action = @full_action.shift
    # 参照したアクションがフルアクショ であれば全体のアクションを統合
    full_act2 = N03::FULLACTION[@action]
    @full_action = full_act2.dup + @full_action if full_act2 != nil
    end
    #--------------------------------------------------------------------------
    # ● 次のアクションへ
    #--------------------------------------------------------------------------
    def next_action
    @wait = 0
    # ショートカット確認
    eval(@action) if @action != nil && @action_data == nil && N03::FULLACTION[@action] == nil
    # ウエイト設定
    @wait = @action.to_i if @wait == 0 && @action_data == nil
    @wait = rand(@wait.abs + 1) if @wait < 0
    # アクション開始
    action_play
    end
    #--------------------------------------------------------------------------
    # ● 待機アクションへ移行
    #--------------------------------------------------------------------------
    def stand_by_action
    # 通常待機に
    stand_by_act = normal
    # HPが1/4でピンチアクションに
    stand_by_act = pinch if @battler.hp <= @battler.mhp / 4
    # ステートチェック
    stand_by_act = state(@battler.states[0].id) if @battler.states[0] != nil && state(@battler.states[0].id) != nil
    # コマンドチェック
    stand_by_act = command if @command_action && command != nil
    set_action(stand_by_act)
    @action = stand_by_act if @action == nil
    end
    #--------------------------------------------------------------------------
    # ● 強制アクション開始
    #--------------------------------------------------------------------------
    def start_force_action
    return if @active
    start_action(@force_action)
    @force_action = ""
    end
    #--------------------------------------------------------------------------
    # ● アクション追加
    #--------------------------------------------------------------------------
    def add_action(kind)
    @full_action.push(kind)
    end
    #--------------------------------------------------------------------------
    # ● アクションの挿入
    #--------------------------------------------------------------------------
    def unshift_action(kind)
    @full_action.unshift(kind)
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def update
    # アクション開始
    start_action
    # 強制アクション開始
    start_force_action if @force_action != ""
    # アニメパターン更新
    update_pattern
    # 移動更新
    update_move
    # 回転更新
    update_angle if @angle_time != 0
    # 拡大縮小更新
    update_zoom if @zoom_time != 0
    # 透明度更新
    update_opacity if @opacity_data != []
    end
    #--------------------------------------------------------------------------
    # ● アニメパターン更新
    #--------------------------------------------------------------------------
    def update_pattern
    return @pattern_rest_time -= 1 if @pattern_rest_time != 0
    return if @max_pattern_w == 1 && @max_pattern_h == 1
    @pattern_rest_time = @pattern_time
    # 再生開始・終了セル位置を取得
    if @pattern_kind > 0 # 通常再生中
    @pattern_start = 0
    @pattern_end = @max_pattern_w - 1
    elsif @pattern_kind < 0 # 逆転再生中
    @pattern_start = @max_pattern_w - 1
    @pattern_end = 0
    end
    # 片道の再生が終了
    @pattern_count += 1 if @pattern_w == @pattern_end && @pattern_kind != 0
    # ループ処理
    case @pattern_type.abs
    when 1,3 # 片道
    @pattern_kind = 0 if @pattern_count != 0 && @pattern_type == 1
    @pattern_kind = 0 if @pattern_count != 0 && @pattern_type == -1
    @pattern_kind = 1 if @pattern_count != 0 && @pattern_type == 3
    @pattern_kind = -1 if @pattern_count != 0 && @pattern_type == -3
    @pattern_w = @pattern_start - @pattern_kind if @pattern_count != 0 && @pattern_type.abs == 3
    @pattern_count = 0
    when 2,4 # 往復
    @pattern_kind = -1 if @pattern_count == 1 && @pattern_type == 2
    @pattern_kind = 1 if @pattern_count == 1 && @pattern_type == -2
    @pattern_kind = 0 if @pattern_count == 2 && @pattern_type == 2
    @pattern_kind = 0 if @pattern_count == 2 && @pattern_type == -2
    @pattern_kind = -1 if @pattern_count == 1 && @pattern_type == 4
    @pattern_kind = 1 if @pattern_count == 1 && @pattern_type == -4
    @pattern_kind = 1 if @pattern_count == 2 && @pattern_type == 4
    @pattern_kind = -1 if @pattern_count == 2 && @pattern_type == -4
    @pattern_count = 0 if @pattern_count == 2
    end
    # セル更新
    @pattern_w += 1 * @pattern_kind
    @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
    end
    #--------------------------------------------------------------------------
    # ● 移動の更新
    #--------------------------------------------------------------------------
    def update_move
    @z = @y / 100 + @z_plus
    return if @move_time == 0
    target_position_set if @horming_move
    @x = (@x * (@move_time - 1) + @target_x) / @move_time
    @y = (@y * (@move_time - 1) + @target_y) / @move_time
    @h = (@h * (@move_time - 1) + @target_h) / @move_time if @move_h != nil
    @c += @curve[@move_time - 1] if @curve[@move_time - 1] != nil
    @j += @jump[@move_time - 1] if @jump[@move_time - 1] != nil
    @move_time -= 1
    convert_jump if @move_time == 0
    end
    #--------------------------------------------------------------------------
    # ● 移動目標の更新
    #--------------------------------------------------------------------------
    def target_position_set
    target_position = N03.get_targets_position(@move_targets, @horming_move)
    @target_x = target_position[0] + @move_x
    @target_y = target_position[1] + @move_y
    @target_h = target_position[2] + @move_h if @move_h != nil
    end
    #--------------------------------------------------------------------------
    # ● 回転更新
    #--------------------------------------------------------------------------
    def update_angle
    @angle += @angling
    @angle_time -= 1
    return if @angle_time != 0
    return angle_reset if @angle_data[4] == 0
    angling(@angle_data) if @angle_data[4] == 2
    end
    #--------------------------------------------------------------------------
    # ● 拡大縮小更新
    #--------------------------------------------------------------------------
    def update_zoom
    @zoom_x += @zooming_x
    @zoom_y += @zooming_y
    @zoom_time -= 1
    return if @zoom_time != 0
    return zoom_reset if @zoom_data[4] == 0
    zooming(@zoom_data) if @zoom_data[4] == 2
    end
    #--------------------------------------------------------------------------
    # ● 透明度更新
    #--------------------------------------------------------------------------
    def update_opacity
    @opacity += @opacity_data[2]
    @opacity_data[0] -= 1
    return if @opacity_data[0] != 0
    return if !@opacity_data[5]
    @opacity_data[2] *= -1
    @opacity_data[0] = @opacity_data[1]
    end
    #--------------------------------------------------------------------------
    # ● アクション実行
    #--------------------------------------------------------------------------
    def action_play
    return if @action_data == nil
    action = @action_data[0]
    # バトラー反転の場合
    return mirroring if action == "mirror"
    # 残像の場合
    return mirage_set if action == "mirage"
    # 回転の場合
    return angling if action == "angle"
    # 拡大縮小の場合
    return zooming if action == "zoom"
    # 透明度操作の場合
    return set_opacity if action == "opacity"
    # バトラーアニメの場合
    return battler_anime if action == "motion"
    # 移動の場合
    return move if action == "move"
    # 武器アニメの場合
    return weapon_anime([@action_data]) if action == "wp"
    # アニメ飛ばしの場合
    return move_anime if action == "m_a"
    # 戦闘シーン通信の場合(コラプス)
    return set_play_data if action == "collapse" or action == "no_collapse"
    # データベース戦闘アニメ表示の場合
    return battle_anime if action == "anime"
    # カメラワークの場合
    return camera if action == "camera"
    # 画面のシェイクの場合
    return shake if action == "shake"
    # 画面色調変更の場合
    return color_effect if action == "color"
    # トランジションの場合
    return transition if action == "ts"
    # ふきだしアニメ表示の場合
    return balloon_anime if action == "balloon"
    # ピクチャ表示の場合
    return picture_set if action == "pic"
    # ステート操作の場合
    return state_set if action == "sta"
    # FPS変更の場合
    return fps if action == "fps"
    # バトラー画像変更の場合
    return graphics_change if action == "change"
    # スキル派生の場合
    return derivating_skill if action == "der"
    # BGM/BGS/SE演奏の場合
    return sound if action == "sound"
    # ムービー再生の場合
    return movie if action == "movie"
    # ゲームスイッチ操作の場合
    return switches if action == "switch"
    # ゲーム変数操作の場合
    return variable if action == "variable"
    # 条件分岐(ゲームスイッチ)の場合
    return nece_1 if action == "n_1"
    # 条件分岐(ゲーム変数)の場合
    return nece_2 if action == "n_2"
    # 条件分岐(ステート)の場合
    return nece_3 if action == "n_3"
    # 条件分岐(スキル)の場合
    return nece_4 if action == "n_4"
    # 条件分岐(パラメータ)の場合
    return nece_5 if action == "n_5"
    # 条件分岐(装備)の場合
    return nece_6 if action == "n_6"
    # 条件分岐(スクリプト)の場合
    return nece_7 if action == "n_7"
    # セカンドターゲット操作の場合
    return second_targets_set if action == "s_t"
    # コモンイベント呼び出しの場合
    return call_common_event if action == "common"
    # 戦闘アニメ消去の場合
    return @anime_off = true if action == "anime_off"
    # 強制戦闘終了の場合
    return BattleManager.process_abort if action == "battle_end"
    # 画面固定の場合
    return Graphics.freeze if action == "graphics_freeze"
    # ダメージアニメの場合
    return damage_anime if action == "damage_anime"
    # 武器消去の場合
    return @weapon_visible = false if action == "weapon_off"
    # 武器消去解除の場合
    return @weapon_visible = true if action == "weapon_on"
    # 待機キャンセルの場合
    return @non_motion = true if action == "non_motion"
    # 待機キャンセル解除の場合
    return @non_motion = false if action == "non_motion_cancel"
    # 初期位置変更の場合
    return change_base_position if action == "change_base_position"
    # 初期位置変更解除の場合
    return set_base_position(false) if action == "set_base_position"
    # 強制アクションの場合
    return force_act if action == "force_action"
    # 強制アクションの場合 (セカンドターゲット)
    return force_act2 if action == "force_action2"
    # 個別開始の場合
    return individual_start if action == "individual_start"
    # 個別終了の場合
    return individual_end if action == "individual_end"
    # ループ開始の場合
    return loop_start if action == "loop_start"
    # ループ終了の場合
    return loop_end if action == "loop_end"
    # 自分のみ更新の場合
    return only_action_on if action == "only_action_on"
    # 自分のみ更新解除の場合
    return only_action_off if action == "only_action_off"
    # 次の行動者へ移行の場合
    return next_battler if action == "next_battler"
    # 画像変更フラグの場合
    return set_change if action == "set_change"
    # スクリプト操作の場合
    return eval(@action_data[0])
    end
    #--------------------------------------------------------------------------
    # ● バトラー反転実行
    #--------------------------------------------------------------------------
    def mirroring
    @mirror = !@mirror
    end
    #--------------------------------------------------------------------------
    # ● 反転初期化
    #--------------------------------------------------------------------------
    def mirroring_reset
    @mirror = false
    mirroring if !@battler.actor? && N03::ENEMY_MIRROR
    mirroring if $sv_camera.mirror
    end
    #--------------------------------------------------------------------------
    # ● 残像実行
    #--------------------------------------------------------------------------
    def mirage_set
    @mirage = @action_data.dup
    @mirage_end = @mirage[3]
    @mirage = [] if @mirage[1] == 0
    end
    #--------------------------------------------------------------------------
    # ● 回転実行
    #--------------------------------------------------------------------------
    def angling(data = @action_data)
    @angle_data = data.dup
    @oy = @ch / 2
    @oy_adjust = @ch * 50
    @angle_time = data[1]
    start_angle = data[2] * N03.mirror_num(@mirror)
    end_angle = data[3] * N03.mirror_num(@mirror)
    # 時間が0以下なら即座に最終角度へ
    @angle_time = 1 if @angle_time <= 0
    # 回転時間から1フレームあたりの角度 出す
    @angling = (end_angle - start_angle) / @angle_time
    # 割り切れない余りを初期角度に
    @angle = (end_angle - start_angle) % @angle_time + start_angle
    end
    #--------------------------------------------------------------------------
    # ● 回転初期化
    #--------------------------------------------------------------------------
    def angle_reset
    @oy = @ch
    @angle = @angle_time = @oy_adjust = 0
    end
    #--------------------------------------------------------------------------
    # ● 拡大縮小実行
    #--------------------------------------------------------------------------
    def zooming(data = @action_data)
    @zoom_data = data.dup
    @zoom_time = data[1]
    start_zoom_x = data[2][0]
    start_zoom_y = data[2][1]
    end_zoom_x = data[3][0]
    end_zoom_y = data[3][1]
    # 時間が0以下なら即座に最終サイズへ
    @zoom_time = 1 if @zoom_time <= 0
    # 拡大縮小時間から1フレームあたりの 大縮小率を出す
    @zooming_x = (end_zoom_x - start_zoom_x) / @zoom_time
    @zooming_y = (end_zoom_y - start_zoom_y) / @zoom_time
    # 開始サイズに
    @zoom_x = start_zoom_x
    @zoom_y = start_zoom_y
    end
    #--------------------------------------------------------------------------
    # ● 拡大縮小初期化
    #--------------------------------------------------------------------------
    def zoom_reset
    @zoom_x = @zoom_y = 1
    @zoom_time = 0
    end
    #--------------------------------------------------------------------------
    # ● バトラー透明度操作
    #--------------------------------------------------------------------------
    def set_opacity
    data = @action_data.dup
    @opacity = data[2]
    opacity_move = (data[3] - data[2])/ data[1]
    @opacity_data = [data[1], data[1], opacity_move, data[4], data[5], data[6]]
    @wait = data[1] if data[7]
    @wait *= 2 if data[6] && data[7]
    end
    #--------------------------------------------------------------------------
    # ● 透明度操作初期化
    #--------------------------------------------------------------------------
    def opacity_reset
    @opacity = 255
    @opacity = 0 if @battler.hidden?
    @opacity_data = []
    end
    #--------------------------------------------------------------------------
    # ● バトラーアニメ実行
    #--------------------------------------------------------------------------
    def battler_anime(anime_data = nil)
    anime_data = @action_data.dup if anime_data == nil
    @graphic_file_index = anime_data[1] if !graphic_fix
    @pattern_h = anime_data[2]
    @pattern_w = anime_data[3]
    @pattern_h = 0 if @max_pattern_w == 1
    @pattern_w = 0 if @max_pattern_h == 1
    @pattern_type = anime_data[4]
    @pattern_time = anime_data[5]
    @pattern_rest_time = anime_data[5]
    @pattern_count = 0
    @pattern_kind = 1
    @pattern_kind = -1 if @pattern_type < 0
    @pattern_kind = 0 if @pattern_type == 0
    @sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
    @sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch
    @z_plus = anime_data[6]
    @wait = set_anime_wait if anime_data[7]
    @shadow_visible = anime_data[8]
    weapon_anime(anime_data)
    end
    #--------------------------------------------------------------------------
    # ● アニメウエイト計算
    #--------------------------------------------------------------------------
    def set_anime_wait
    if @pattern_type > 0
    pattern_time_a = @max_pattern_w - @pattern_w.abs
    elsif @pattern_type < 0
    pattern_time_a = @pattern_w.abs + 1
    else
    return @pattern_time if @pattern_type == 0
    end
    case @pattern_type
    when 1,-1, 3,-3
    return pattern_time_a * @pattern_time
    when 2,-2, 4,-4
    return pattern_time_a * @pattern_time + (@max_pattern_w - 2) * @pattern_time
    end
    end
    #--------------------------------------------------------------------------
    # ● 移動実行
    #--------------------------------------------------------------------------
    def move
    @move_targets = N03.get_targets(@action_data[1].abs, @battler)
    return if @move_targets == []
    @move_targets = [@battler] if @action_data[1].abs == 7
    @move_x = @action_data[2] * 100 * N03.mirror_num(@mirror)
    @move_y = @action_data[3] * 100
    @move_h = @action_data[4] * 100 if @action_data[4] != nil
    @move_h = nil if @action_data[4] == nil
    battler_anime(N03::ACTION[@action_data[8]].dup) if N03::ACTION[@action_data[8]] != nil
    @horming_move = true
    @horming_move = false if @action_data[1] < 0 or @action_data[1].abs == 7
    target_position_set
    target_position = [@target_x, @target_y, @target_z]
    distanse_move = @action_data[5] > 0
    @move_time = N03.distanse_calculation(@action_data[5].abs, target_position, [@x, @y, @z], distanse_move)
    @wait = @move_time
    curve
    jump
    @move_time = 1 if @move_time == 0
    @horming_move = false if !@move_targets or @move_targets.include?(@battler)
    update_move if @move_time == 1
    end
    #--------------------------------------------------------------------------
    # ● カーブ実行
    #--------------------------------------------------------------------------
    def curve
    @c = 0
    return if @action_data[6] == 0
    @curve = N03.parabola([@action_data[6], -@action_data[6]], @move_time, 100, 4)
    end
    #--------------------------------------------------------------------------
    # ● ジャンプ実行
    #--------------------------------------------------------------------------
    def jump
    convert_jump
    return if @action_data[7] == [0,0]
    @jump = N03.parabola(@action_data[7].dup, @move_time, 100)
    end
    #--------------------------------------------------------------------------
    # ● J座標(ジャンプ高度)をH座標に変換
    #--------------------------------------------------------------------------
    def convert_jump
    @h += @j
    @j = 0
    @jump = []
    end
    #--------------------------------------------------------------------------
    # ● データベース戦闘アニメ実行
    #--------------------------------------------------------------------------
    def battle_anime
    data = @action_data.dup
    targets = N03.get_targets(data[2], @battler)
    return if targets == []
    data[8] = !data[8] if @mirror
    @set_damage = data[5]
    @damage_anime_data[0] = N03.get_attack_anime_id(data[1], @battler)
    @damage_anime_data[1] = data[8]
    @damage_anime_data[2] = data[7]
    @damage_anime_data[3] = data[6]
    @damage_anime_data[4] = data[9]
    @wait = N03.get_anime_time(@damage_anime_data[0]) - 2 if data[4]
    return if @set_damage
    for target in targets do display_anime(targets, target, data) end
    end
    #--------------------------------------------------------------------------
    # ● 武器アニメ開始
    #--------------------------------------------------------------------------
    def weapon_anime(anime_data)
    @weapon_end = true
    for i in 9...anime_data.size
    set_effect_data(anime_data[i]) if anime_data[i] != ""
    end
    end
    #--------------------------------------------------------------------------
    # ● アニメ飛ばし開始
    #--------------------------------------------------------------------------
    def move_anime
    @m_a_starter = []
    @m_a_targets = []
    starters = N03.get_targets(@action_data[2], @battler)
    targets = N03.get_targets(@action_data[3], @battler)
    return if starters == [] or targets == []
    single_start = true if starters != nil && @action_data[2] < 0
    single_start = true if @action_data[1][0] != 0 && $data_animations[N03.get_attack_anime_id(@action_data[1][0], @battler)].position == 3
    starters = [starters[0]] if single_start
    single_end = true if targets != nil && @action_data[3] < 0
    single_end = true if @action_data[1][1] != 0 && $data_animations[N03.get_attack_anime_id(@action_data[1][1], @battler)].position == 3
    targets = [targets[0]] if single_end
    se_flag = true
    for starter in starters
    for target in targets
    data = @action_data.dup
    data[17] = se_flag
    @effect_data.push(data)
    @m_a_targets.push(target)
    @m_a_starter.push(starter)
    se_flag = false
    end
    end
    end
    #--------------------------------------------------------------------------
    # ● スプライトセット通信
    #--------------------------------------------------------------------------
    def set_effect_data(data = @action)
    action_data = N03::ACTION[data]
    return if action_data == nil
    @effect_data.push(action_data.dup)
    end
    #--------------------------------------------------------------------------
    # ● 戦闘シーン通信のデータを格納
    #--------------------------------------------------------------------------
    def set_play_data(data = @action_data)
    @play_data = data.dup
    end
    #--------------------------------------------------------------------------
    # ● 戦闘アニメの表示
    #--------------------------------------------------------------------------
    def display_anime(targets, target, data)
    return if !N03.first_of_all_screen_anime(data[1], target, targets)
    target.animation_id = N03.get_attack_anime_id(data[1], @battler)
    target.animation_mirror = data[8]
    target.sv.anime_horming = data[3]
    target.sv.anime_camera_zoom = data[6]
    target.sv.anime_no_mirror = data[7]
    target.sv.anime_plus_z = data[9]
    end
    #--------------------------------------------------------------------------
    # ● 戦闘アニメ拡張データの初期化
    #--------------------------------------------------------------------------
    def reset_anime_data
    @anime_no_mirror = false
    @anime_horming = false
    @anime_camera_zoom = false
    @timing_targets = []
    @anime_plus_z = true
    end
    #--------------------------------------------------------------------------
    # ● カメラワーク
    #--------------------------------------------------------------------------
    def camera
    data = @action_data.dup
    N03.camera(@battler, data)
    @wait = data[4] if data[5]
    end
    #--------------------------------------------------------------------------
    # ● 画面のシェイク
    #--------------------------------------------------------------------------
    def shake
    data = @action_data.dup
    $sv_camera.shake(data[1], data[2], data[3])
    @wait = data[3] if data[4]
    end
    #--------------------------------------------------------------------------
    # ● 画面色調変更
    #--------------------------------------------------------------------------
    def color_effect
    case @action_data[1]
    when 0,1,2,3,4,5
    targets = N03.get_targets(@action_data[1], @battler)
    when 6
    screen = true
    when 7
    targets = [@battler] + @target_battler
    when 8
    screen = true
    targets = $game_troop.members + $game_party.battle_members - [@battler]
    when 9
    screen = true
    targets = $game_troop.members + $game_party.battle_members - [@battler] - @target_battler
    when 10
    screen = true
    targets = $game_troop.members + $game_party.battle_members
    end
    return if screen == nil && targets == []
    for target in targets do target.sv.color_set = @action_data[2] end if targets
    @wait = @action_data[2][4] if @action_data[3]
    return if !screen
    $sv_camera.color_set[1] = @action_data[2]
    $sv_camera.color_set[2] = @action_data[2]
    end
    #--------------------------------------------------------------------------
    # ● トランジション
    #--------------------------------------------------------------------------
    def transition
    $sv_camera.perform_transition(@action_data)
    end
    #--------------------------------------------------------------------------
    # ● ふきだしアニメ表示
    #--------------------------------------------------------------------------
    def balloon_anime
    @balloon_data = @action_data.dup
    end
    #--------------------------------------------------------------------------
    # ● ピクチャ表示
    #--------------------------------------------------------------------------
    def picture_set
    @picture = true
    set_effect_data
    end
    #--------------------------------------------------------------------------
    # ● ステート操作
    #--------------------------------------------------------------------------
    def state_set
    targets = N03.get_targets(@action_data[1], @battler)
    return if targets == []
    case @action_data[2]
    when 1 ; targets = [targets[rand(targets.size)]]
    when 2 ; targets -= @battler if targets.include?(@battler)
    end
    for target in targets
    for id in @action_data[4]
    target.add_state(id) if @action_data[3] == "+"
    target.remove_state(id) if @action_data[3] == "-"
    end
    end
    end
    #--------------------------------------------------------------------------
    # ● FPS変更
    #--------------------------------------------------------------------------
    def fps
    Graphics.frame_rate = @action_data[1]
    start_action
    end
    #--------------------------------------------------------------------------
    # ● バトラー画像変更の場合
    #--------------------------------------------------------------------------
    def graphics_change
    @graphics_change = true
    return @battler.graphics_change(@action_data[3]) if !@battler.actor?
    @pre_change_data = [@battler.character_name, @battler.character_index, @battler.face_name, @battler.face_index] if @pre_change_data == nil && !@action_data[1]
    if @action_data[4] == []
    face_name = @battler.face_name
    face_index = @battler.face_index
    else
    face_name = @action_data[4][1]
    face_index = @action_data[4][0]
    end
    @battler.set_graphic(@action_data[3], @action_data[2], face_name, face_index)
    end
    #--------------------------------------------------------------------------
    # ● スキル派生
    #--------------------------------------------------------------------------
    def derivating_skill
    # 未修得スキルは派生不可なら
    return if !@action_data[1] && !@battler.skill_learn?($data_skills[@action_data[3]])
    # コスト不足は派生不可なら
    return if !@action_data[2] && !@battler.skill_cost_payable?($data_skills[@action_data[3]])
    # 派生
    @derivation_skill_id = @action_data[3]
    # 以降のアクションをキャンセル
    @full_action = []
    end
    #--------------------------------------------------------------------------
    # ● BGM/BGS/SE演奏
    #--------------------------------------------------------------------------
    def sound
    pitch = @action_data[2]
    vol = @action_data[3]
    name = @action_data[4]
    case @action_data[1]
    when "se"
    Audio.se_play("Audio/SE/" + name, vol, pitch)
    when "bgm"
    # 名前指定のない場合、現在のBGMを変 ないように
    name = RPG::BGM.last.name if @action_data[4] == ""
    Audio.bgm_play("Audio/BGM/" + name, vol, pitch)
    when "bgs"
    name = RPG::BGS.last.name if @action_data[4] == ""
    Audio.bgs_play("Audio/BGS/" + name, vol, pitch)
    end
    end
    #--------------------------------------------------------------------------
    # ● ムービーの再生
    #--------------------------------------------------------------------------
    def movie
    Graphics.play_movie('Movies/' + @action_data[1])
    end
    #--------------------------------------------------------------------------
    # ● ゲームスイッチ操作
    #--------------------------------------------------------------------------
    def switches
    for id in @action_data[1]
    $game_switches[id] = true if id > 0
    $sv_camera.switches[id.abs] = true if id < 0
    end
    for id in @action_data[2]
    $game_switches[id] = false if id > 0
    $sv_camera.switches[id.abs] = false if id < 0
    end
    $sv_camera.program_check
    end
    #--------------------------------------------------------------------------
    # ● ゲーム変数操作
    #--------------------------------------------------------------------------
    def variable
    # オペランドチェック
    operand = @action_data[3]
    operand = $game_variables[@action_data[3].abs] if @action_data[3] < 0
    # 変数操作で分岐
    case @action_data[2]
    when 0 ; $game_variables[@action_data[1]] = operand # 代入
    when 1 ; $game_variables[@action_data[1]] += operand # 加算
    when 2 ; $game_variables[@action_data[1]] -= operand # 減算
    when 3 ; $game_variables[@action_data[1]] *= operand # 乗算
    when 4 ; $game_variables[@action_data[1]] /= operand # 除算
    when 5 ; $game_variables[@action_data[1]] %= operand # 剰余
    end
    end
    #--------------------------------------------------------------------------
    # ● 条件分岐 (ゲームスイッチ)
    #--------------------------------------------------------------------------
    def nece_1
    judgment = $game_switches[@action_data[1]] == @action_data[2] if @action_data[1] > 0
    judgment = $sv_camera.switches[@action_data[1].abs] == @action_data[2] if @action_data[1] < 0
    action_diverging(judgment, @action_data[3])
    end
    #--------------------------------------------------------------------------
    # ● 条件分岐 (ゲーム変数)
    #--------------------------------------------------------------------------
    def nece_2
    variable = $game_variables[@action_data[1]]
    num = @action_data[2]
    num = $game_variables[@action_data[2].abs] if num < 0
    case @action_data[3]
    when 0 ; judgment = variable == num
    when 1 ; judgment = variable < num
    when 2 ; judgment = variable > num
    end
    action_diverging(judgment, @action_data[4])
    end
    #--------------------------------------------------------------------------
    # ● 条件分岐 (ステート)
    #--------------------------------------------------------------------------
    def nece_3
    targets = N03.get_targets(@action_data[1], @battler)
    return if targets == []
    member_num = @action_data[4]
    member_num = targets.size if @action_data[4] == 0 && targets.size > 1
    hit_count = 0
    miss_count = 0
    for target in targets
    hit_count += 1 if target.state?(@action_data[2])
    miss_count += 1 if !target.state?(@action_data[2])
    end
    case @action_data[3]
    when 0 ; judgment = hit_count >= member_num
    when 1 ; judgment = miss_count >= member_num
    end
    action_diverging(judgment, @action_data[5])
    end
    #--------------------------------------------------------------------------
    # ● 条件分岐 (スキル)
    #--------------------------------------------------------------------------
    def nece_4
    targets = N03.get_targets(@action_data[1], @battler)
    return if targets == []
    member_num = @action_data[4]
    member_num = targets.size if @action_data[4] == 0 && targets.size > 1
    hit_count = 0
    miss_count = 0
    for target in targets
    hit_count += 1 if target.skill_learn?($data_skills[@action_data[2]]) && target.skill_conditions_met?($data_skills[@action_data[2]])
    miss_count += 1 if !target.skill_learn?($data_skills[@action_data[2]]) or !target.skill_conditions_met?($data_skills[@action_data[2]])
    end
    case @action_data[3]
    when 0 ; judgment = hit_count >= member_num
    when 1 ; judgment = miss_count >= member_num
    end
    action_diverging(judgment, @action_data[5])
    end
    #--------------------------------------------------------------------------
    # ● 条件分岐 (パラメータ)
    #--------------------------------------------------------------------------
    def nece_5
    targets = N03.get_targets(@action_data[1], @battler)
    return if targets == []
    member_num = @action_data[5]
    member_num = targets.size if @action_data[5] == 0 && targets.size > 1
    hit_count = 0
    for target in targets
    hit_count += 1 if target.comparison_parameter([@action_data[2],@action_data[3],@action_data[4]])
    end
    judgment = hit_count >= member_num
    action_diverging(judgment, @action_data[6])
    end
    #--------------------------------------------------------------------------
    # ● 条件分岐 (装備)
    #--------------------------------------------------------------------------
    def nece_6
    targets = N03.get_targets(@action_data[1], @battler)
    return if targets == []
    member_num = @action_data[5]
    member_num = targets.size if @action_data[5] == 0 && targets.size > 1
    hit_count = 0
    miss_count = 0
    for target in targets
    hit_count += 1 if target.comparison_equip([@action_data[2],@action_data[3]])
    miss_count += 1 if !target.comparison_equip([@action_data[2],@action_data[3]])
    end
    case @action_data[4]
    when 0 ; judgment = hit_count >= member_num
    when 1 ; judgment = miss_count >= member_num
    end
    action_diverging(judgment, @action_data[6])
    end
    #--------------------------------------------------------------------------
    # ● 条件分岐 (スクリプト)
    #--------------------------------------------------------------------------
    def nece_7
    judgment = eval(@action_data[2])
    action_diverging(judgment, @action_data[1])
    end
    #--------------------------------------------------------------------------
    # ● アクション分岐
    #--------------------------------------------------------------------------
    def action_diverging(judgment, kind)
    result = 0
    if judgment
    result = 1 if kind == 1
    result = 2 if kind == 2
    else
    result = 1 if kind == 0
    end
    # フルアクション終了
    return @full_action = [] if result == 2
    # 次のアクションを除去
    @full_action.shift if result == 1
    set_action
    # 次のアクションを実行
    @action_data = N03::ACTION[@action]
    next_action
    end
    #--------------------------------------------------------------------------
    # ● セカンドターゲット操作
    #--------------------------------------------------------------------------
    def second_targets_set
    targets = N03.get_targets(@action_data[1], @battler)
    for target in targets
    targets.delete(target) if @action_data[2][1] == 1 && target.index != @action_data[2][0]
    targets.delete(target) if @action_data[2][1] == 2 && target.index == @action_data[2][0].abs
    targets.delete(target) if @action_data[3] > 0 && target.id != @action_data[3]
    targets.delete(target) if @action_data[3] < 0 && target.id == @action_data[3].abs
    targets.delete(target) if @action_data[4] > 0 && !target.state?(@action_data[4])
    targets.delete(target) if @action_data[4] < 0 && target.state?(@action_data[4].abs)
    targets.delete(target) if @action_data[5] > 0 && !target.skill_conditions_met?($data_skills[@action_data[5]])
    targets.delete(target) if @action_data[5] < 0 && target.skill_conditions_met?($data_skills[@action_data[5].abs])
    targets.delete(target) if !target.comparison_parameter(@action_data[6])
    targets.delete(target) if !@action_data[7][1].include?(0) && !target.comparison_equip(@action_data[7])
    end
    return @second_targets = [] if targets.size == 0
    case @action_data[8]
    when 1 ; targets = [targets[rand(targets.size)]]
    when 2 ; targets.delete(@battler)
    end
    return @second_targets = [] if targets.size == 0
    @second_targets = targets
    case @action_data[9]
    when 0 ; return
    when 1 ; set_play_data(["second_targets_set"])
    when 2 ; set_play_data(["targets_set"])
    end
    @wait += 1
    end
    #--------------------------------------------------------------------------
    # ● コモンイベント呼び出し
    #--------------------------------------------------------------------------
    def call_common_event
    $game_temp.reserve_common_event(@action_data[1])
    $sv_camera.event = true
    @event_fix = @action_data[2]
    end
    #--------------------------------------------------------------------------
    # ● ダメージアニメ
    #--------------------------------------------------------------------------
    def damage_anime(delay_time = 12)
    anime(N03.get_attack_anime_id(-3, @battler), wait = true)
    action_play
    @wait -= delay_time
    @full_action.unshift("eval('@damage_anime_data = []
    @set_damage = true')")
    end
    #--------------------------------------------------------------------------
    # ● 通常コラプス
    #--------------------------------------------------------------------------
    def normal_collapse
    @collapse = true
    return
    end
    #--------------------------------------------------------------------------
    # ● 初期位置変更
    #--------------------------------------------------------------------------
    def change_base_position
    @base_x = @x
    @base_y = @y
    @base_h = @h
    end
    #--------------------------------------------------------------------------
    # ● 強制アクション実行
    #--------------------------------------------------------------------------
    def force_act
    target(@full_action.shift)
    end
    #--------------------------------------------------------------------------
    # ● 強制アクション実行 (セカンドターゲット)
    #--------------------------------------------------------------------------
    def force_act2
    target2(@full_action.shift)
    end
    #--------------------------------------------------------------------------
    # ● 個別処理開始
    #--------------------------------------------------------------------------
    def individual_start
    @individual_targets = @target_battler.dup
    @remain_targets = @target_battler.dup
    @target_battler = [@individual_targets[0]]
    # リピート部分のアクションを保持
    @individual_act = @full_action.dup
    end
    #--------------------------------------------------------------------------
    # ● 個別処理終了
    #--------------------------------------------------------------------------
    def individual_end
    @individual_targets.shift
    for target in @individual_targets
    @individual_targets.shift if target.dead?
    end
    # ターゲットが残っているなら行動リ ート
    return @target_battler = @remain_targets if @individual_targets.size == 0
    @full_action = @individual_act.dup
    @target_battler = [@individual_targets[0]]
    end
    #--------------------------------------------------------------------------
    # ● ループ開始
    #--------------------------------------------------------------------------
    def loop_start
    # ループ部分のアクションを保持
    @loop_act = @full_action.dup
    end
    #--------------------------------------------------------------------------
    # ● ループ終了
    #--------------------------------------------------------------------------
    def loop_end
    # 行動リピート
    @full_action = @loop_act.dup if @loop_act != []
    end
    #--------------------------------------------------------------------------
    # ● 次の行動者へ移行
    #--------------------------------------------------------------------------
    def next_battler
    @action_end = true
    @active = false
    end
    #--------------------------------------------------------------------------
    # ● 画像変更フラグ
    #--------------------------------------------------------------------------
    def set_change
    @change_up = true
    end
    #--------------------------------------------------------------------------
    # ● 戦闘シーン通信
    #--------------------------------------------------------------------------
    def play_data
    data = @play_data
    @play_data = []
    return data
    end
    #--------------------------------------------------------------------------
    # ● ショートカットコマンド
    #--------------------------------------------------------------------------
    def anime(anime_id, wait = true)
    @action_data = ["anime",anime_id,1,false,wait,false,true,false]
    end
    def anime_me(anime_id, wait = true)
    @action_data = ["anime",anime_id,0,false,wait,false,true,false]
    end
    def se(file, pitch = 100)
    @action_data = ["sound", "se", pitch, 100, file]
    end
    def target(act)
    for target in @target_battler do target.sv.force_action = act end
    end
    def target2(act)
    for target in @second_targets do target.sv.force_action = act end
    end
    def delay(time)
    @wait = @battler.index * time
    end
    #--------------------------------------------------------------------------
    # ● バトラーのIDを取得
    #--------------------------------------------------------------------------
    def id
    return @battler.id if @battler.actor?
    return -@battler.id
    end
    #--------------------------------------------------------------------------
    # ● 被クリティカルフラグを取得
    #--------------------------------------------------------------------------
    def critical?
    return @battler.result.critical
    end
    #--------------------------------------------------------------------------
    # ● 被回復フラグを取得
    #--------------------------------------------------------------------------
    def recovery?
    recovery = false
    recovery = true if @battler.result.hp_damage < 0
    recovery = true if @battler.result.mp_damage < 0
    recovery = true if @battler.result.tp_damage < 0
    return recovery
    end
    #--------------------------------------------------------------------------
    # ● 被スキルIDを取得
    #--------------------------------------------------------------------------
    def damage_skill_id
    return @damage_skill_id
    end
    #--------------------------------------------------------------------------
    # ● 被アイテムIDを取得
    #--------------------------------------------------------------------------
    def damage_item_id
    return @damage_item_id
    end
    #--------------------------------------------------------------------------
    # ● 装備武器を取得
    #--------------------------------------------------------------------------
    def weapon_id
    return 0 if !@battler.weapons[0]
    return @battler.weapons[0].id
    end
    #--------------------------------------------------------------------------
    # ● 装備武器のタイプを取得
    #--------------------------------------------------------------------------
    def weapon_type
    return 0 if !@battler.weapons[0]
    return @battler.weapons[0].wtype_id
    end
    #--------------------------------------------------------------------------
    # ● 盾を装備しているか
    #--------------------------------------------------------------------------
    def shield?
    for armor in @battler.armors do return true if armor != nil && armor.etype_id == 1 end
    return false
    end
    #--------------------------------------------------------------------------
    # ● ダメージがあるか
    #--------------------------------------------------------------------------
    def damage_zero?
    return @battler.result.hp_damage == 0 && @battler.result.mp_damage == 0 && @battler.result.tp_damage == 0
    end
    #--------------------------------------------------------------------------
    # ● スキルIDを取得
    #--------------------------------------------------------------------------
    def skill_id
    return @counter_id if @counter_id != 0
    return 0 if @battler.current_action == nil or @battler.current_action.item == nil
    return 0 if @battler.current_action.item.is_a?(RPG::Item)
    return @battler.current_action.item.id
    end
    #--------------------------------------------------------------------------
    # ● スキルのタイプを取得
    #--------------------------------------------------------------------------
    def skill_type
    return 0 if skill_id == 0
    return $data_skills[skill_id].stype_id
    end
    #--------------------------------------------------------------------------
    # ● スキル名を取得
    #--------------------------------------------------------------------------
    def skill_name
    return "" if skill_id == 0
    return $data_skills[skill_id].name
    end
    #--------------------------------------------------------------------------
    # ● アイテムIDを取得
    #--------------------------------------------------------------------------
    def item_id
    return 0 if @battler.current_action == nil or @battler.current_action.item == nil
    return @battler.current_action.item.id
    end
    #--------------------------------------------------------------------------
    # ● 攻撃アクション
    #--------------------------------------------------------------------------
    def attack_action(item)
    return skill_action if item.is_a?(RPG::Skill)
    return item_action
    end
    #--------------------------------------------------------------------------
    # ● ダメージアクションベース
    #--------------------------------------------------------------------------
    def damage_action_base(item)
    @damage_skill_id = 0
    @damage_item_id = 0
    @damage_skill_id = item.id if item.is_a?(RPG::Skill)
    @damage_item_id = item.id if item.is_a?(RPG::Item)
    end
    #--------------------------------------------------------------------------
    # ● ダメージアクション
    #--------------------------------------------------------------------------
    def damage_action(attacker, item)
    damage_action_base(item)
    act = damage(attacker)
    return if @active
    start_action(act) if act != nil
    end
    #--------------------------------------------------------------------------
    # ● 回避アクション
    #--------------------------------------------------------------------------
    def evasion_action(attacker, item)
    damage_action_base(item)
    act = evasion(attacker)
    return if @active
    start_action(act) if act != nil
    end
    #--------------------------------------------------------------------------
    # ● ミスアクション
    #--------------------------------------------------------------------------
    def miss_action(attacker, item)
    damage_action_base(item)
    act = miss(attacker)
    return if @active
    start_action(act) if act != nil
    end
    #--------------------------------------------------------------------------
    # ● 閃きスクリプト併用処理
    #--------------------------------------------------------------------------
    def flash_action
    return "閃き"
    end

    end


    #================================================= =============================
    # ■ module N03
    #------------------------------------------------------------------------------
    #  サイドビューバトルのモジュール す。
    #================================================= =============================
    module N03
    #--------------------------------------------------------------------------
    # ● バトラーの敵グループを取得
    #--------------------------------------------------------------------------
    def self.get_enemy_unit(battler)
    return $game_troop if battler.actor?
    return $game_party
    end
    #--------------------------------------------------------------------------
    # ● バトラーの味方グループを取得
    #--------------------------------------------------------------------------
    def self.get_party_unit(battler)
    return $game_party if battler.actor?
    return $game_troop
    end
    #--------------------------------------------------------------------------
    # ● 戦闘アニメ時間の取得
    #--------------------------------------------------------------------------
    def self.get_anime_time(anime_id)
    return 0 if anime_id <= 0
    return $data_animations[anime_id].frame_max * 4
    end
    #--------------------------------------------------------------------------
    # ● 攻撃アニメの取得
    #--------------------------------------------------------------------------
    def self.get_attack_anime_id(kind, battler)
    return $data_skills[battler.sv.counter_id].animation_id if kind == -3 && battler.sv.counter_id != 0
    case kind
    when -1 ; anime_id = battler.atk_animation_id1
    when -2 ; anime_id = battler.atk_animation_id2
    when -3
    if battler.current_action != nil
    anime_id = battler.current_action.item.animation_id if battler.current_action.item != nil
    end
    else ; anime_id = kind
    end
    case anime_id
    when -1 ; anime_id = battler.atk_animation_id1
    when -2 ; anime_id = battler.atk_animation_id2
    end
    return anime_id if anime_id
    return 0
    end
    #--------------------------------------------------------------------------
    # ● 戦闘アニメデータをセット
    #--------------------------------------------------------------------------
    def self.set_damage_anime_data(targets, target, data)
    return if !first_of_all_screen_anime(data[0], target, targets)
    target.animation_id = data[0]
    target.animation_mirror = data[1]
    target.sv.anime_no_mirror = data[2]
    target.sv.anime_camera_zoom = data[3]
    target.sv.anime_plus_z = data[4]
    end
    #--------------------------------------------------------------------------
    # ● ターゲットの取得
    #--------------------------------------------------------------------------
    def self.get_targets(kind, battler)
    case kind.abs
    when 0 ; return [battler].dup
    when 1 ; return battler.sv.target_battler.dup
    when 2 ; return get_enemy_unit(battler).members.dup
    when 3 ; return get_party_unit(battler).members.dup
    when 4 ; return $game_troop.members.dup + $game_party.battle_members.dup
    when 5 ; return battler.sv.second_targets.dup
    end
    end
    #--------------------------------------------------------------------------
    # ● ターゲットの座標を取得
    #--------------------------------------------------------------------------
    def self.get_targets_position(targets, horming, m_a = nil)
    return [0,0,0] if targets == nil && !$sv_camera.mirror
    return [Graphics.width,0,0] if targets == nil && $sv_camera.mirror
    x = y = h = 0
    for i in 0...targets.size
    x += targets[i].sv.base_x if !horming
    y += targets[i].sv.base_y if !horming
    h += targets[i].sv.base_h if !horming
    x += targets[i].sv.x if horming
    y += targets[i].sv.y if horming
    h += targets[i].sv.h if horming
    y -= targets[i].sv.ch * 100 if m_a == 0
    y -= targets[i].sv.ch * 50 if m_a == 1
    end
    return [x / targets.size, y / targets.size, h / targets.size]
    end
    #--------------------------------------------------------------------------
    # ● 速度を時間に変換
    #--------------------------------------------------------------------------
    def self.distanse_calculation(time, target_position, self_position, distanse_move)
    return time if !distanse_move
    distanse_x = self_position[0] - target_position[0]
    distanse_x = target_position[0] - self_position[0] if target_position[0] > self_position[0]
    distanse_y = self_position[1] - target_position[1]
    distanse_y = target_position[1] - self_position[1] if target_position[1] > self_position[1]
    if self_position[2] != nil && target_position[2] != nil
    distanse_h = self_position[2] - target_position[2]
    distanse_h = target_position[2] - self_position[2] if target_position[2] > self_position[2]
    else
    distanse_h = 0
    end
    distanse = [distanse_x, distanse_y, distanse_h].max
    return distanse / (time * 100) + 1
    end
    #--------------------------------------------------------------------------
    # ● 放物線移動計算
    #--------------------------------------------------------------------------
    def self.parabola(data, time, size, type = 1)
    move_data = data
    move_data[0] *= size
    move_data[1] *= size
    move = []
    move_d = []
    for i in 0...time / 2
    move[i] = move_data[0]
    move_d[i] = move_data[1]
    move_data[0] = move_data[0] * type / (1 + type)
    move_data[1] = move_data[1] * type / (1 + type)
    end
    move = move + move_d.reverse!
    move.reverse!
    adjust = move.inject(0) {|result, item| result + item }
    move[move.size - 1] += adjust if data[0] == data[1] && adjust != 0
    move.unshift(0) if time % 2 != 0
    return move
    end
    #--------------------------------------------------------------------------
    # ● 反転値
    #--------------------------------------------------------------------------
    def self.mirror_num(mirror)
    return 1 if !mirror
    return -1
    end
    #--------------------------------------------------------------------------
    # ● カメラワーク
    #--------------------------------------------------------------------------
    def self.camera(battler, data)
    battler = $game_party.battle_members[0] if !battler
    cx = data[2][0] * 100
    cy = data[2][1] * 100
    return $sv_camera.move(cx, cy, data[3], data[4], true) if data[1] == 6
    targets = self.get_targets(data[1], battler)
    return if targets == nil or targets == []
    position = self.get_targets_position(targets, true)
    $sv_camera.move(position[0], position[1] - position[2], data[3], data[4], false)
    end
    #--------------------------------------------------------------------------
    # ● コラプス禁止
    #--------------------------------------------------------------------------
    def self.immortaling
    # 全員に不死身付与
    for member in $game_party.battle_members + $game_troop.members
    # イベント操作等で不死身設定になっ いたら解除を無効にするフラグを立 る
    member.sv.immortal = true if member.state?(N03::IMMORTAL_ID)
    member.add_state(N03::IMMORTAL_ID)
    end
    return true
    end
    #--------------------------------------------------------------------------
    # ● コラプス許可
    #--------------------------------------------------------------------------
    def self.unimmortaling
    # 全員の不死身化解除(イベント等で不 身設定がされていれば除く)
    for member in $game_party.battle_members + $game_troop.members
    next if member.dead?
    # 不死身ステートが行動中に解除され いた場合、解除無効を解除
    member.sv.immortal = false if !member.state?(N03::IMMORTAL_ID) && member.sv.immortal
    next member.sv.immortal = false if member.sv.immortal
    member.remove_state(N03::IMMORTAL_ID)
    next if member.hp != 0
    member.add_state(1)
    member.perform_collapse_effect
    member.sv.action_terminate
    end
    return false
    end
    #--------------------------------------------------------------------------
    # ● スキル派生
    #--------------------------------------------------------------------------
    def self.derived_skill(battler)
    battler.force_action(battler.sv.derivation_skill_i d, -2)
    BattleManager.unshift_action_battlers(battler)
    end
    #--------------------------------------------------------------------------
    # ● ダメージの作成
    #--------------------------------------------------------------------------
    def self.set_damage(battler, hp_damage, mp_damage)
    battler.result.hp_damage = hp_damage
    battler.result.mp_damage = mp_damage
    end
    #--------------------------------------------------------------------------
    # ● ターゲット生死確認
    #--------------------------------------------------------------------------
    def self.targets_alive?(targets)
    return false if targets == []
    for target in targets do return true if !target.dead? end
    return false
    end
    #--------------------------------------------------------------------------
    # ● ターゲットをセカンドターゲットへ
    #--------------------------------------------------------------------------
    def self.s_targets(battler)
    battler.sv.target_battler = battler.sv.second_targets
    return battler.sv.second_targets
    end
    #--------------------------------------------------------------------------
    # ● セカンドターゲットをターゲットへ
    #--------------------------------------------------------------------------
    def self.targets_set(battler)
    battler.sv.second_targets = battler.current_action.make_targets.compact
    battler.sv.target_battler = battler.sv.second_targets
    end
    #--------------------------------------------------------------------------
    # ● 戦闘アニメ実行判定 (対象:画面時は最初のターゲットの アニメ実行)
    #--------------------------------------------------------------------------
    def self.first_of_all_screen_anime(anime_id, target, targets)
    anime = $data_animations[anime_id]
    return false if !anime
    return true if anime.position != 3
    return false if anime.position == 3 && target != targets[0]
    targets.delete(target)
    target.sv.timing_targets = targets
    return true
    end
    #--------------------------------------------------------------------------
    # ● 戦闘不能付加攻撃か
    #--------------------------------------------------------------------------
    def self.dead_attack?(battler, item)
    for state in battler.atk_states
    return true if state == battler.death_state_id
    end
    for effect in item.effects
    return true if effect.code == 21 && effect.data_id == battler.death_state_id
    end
    return false
    end
    end

    #================================================= =============================
    # ■ Sprite_Weapon
    #------------------------------------------------------------------------------
    #  ウエポン表示用のスプライトです
    #================================================= =============================
    class Sprite_Weapon < Sprite_Base
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数 
    #--------------------------------------------------------------------------
    attr_reader :index # ウエポン画像配列のインデックス
    attr_reader :battler # 画像が参照しているバトラー
    attr_reader :move_time # 画像が目標に到達するまでの時間
    attr_reader :through # 貫通フラグ
    attr_reader :action_end # 武器アクション終了フラグ
    attr_reader :action_end_cancel # 武器アクション終了フラグ
    attr_reader :hit_position # 画像が目標に到達した時の座標
    attr_accessor :hit_anime_id # 画像が目標に到達した時のアニメID
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    def initialize(viewport, index, battler)
    super(viewport)
    @index = index
    @battler = battler
    @position_x = @position_y = 0
    @o = 0
    @real_x = @real_y = 0
    @mirror = @battler.sv.mirror
    reset
    set_action
    end
    #--------------------------------------------------------------------------
    # ● 初期化
    #--------------------------------------------------------------------------
    def reset
    @z_plus = 0
    @weapon_data = []
    @move_data = []
    @move_x = 0
    @move_y = 0
    @orbit = []
    @through = false
    @distanse_move = false
    @weapon_width = 0
    @weapon_height = 0
    @anime_time = 0
    @anime_position = 1
    @move_time = 0
    @hit_anime_id = 0
    @move_anime = true
    @action_end = false
    @action_end_cancel = false
    reset_position
    end
    #--------------------------------------------------------------------------
    # ● アクションをセット
    #--------------------------------------------------------------------------
    def set_action
    return if @battler.sv.effect_data == []
    weapon_anime if @battler.sv.effect_data[0][0] == "wp"
    move_anime if @battler.sv.effect_data[0][0] == "m_a"
    @battler.sv.effect_data.shift
    end
    #--------------------------------------------------------------------------
    # ● 武器アニメ実行
    #--------------------------------------------------------------------------
    def weapon_anime
    @weapon_data = @battler.sv.effect_data[0].dup
    set_graphics
    set_ox
    set_weapon_move
    end
    #--------------------------------------------------------------------------
    # ● アニメ移動実行
    #--------------------------------------------------------------------------
    def move_anime
    @move_data = @battler.sv.effect_data[0].dup
    # ターゲットを取得
    @target_battler = [@battler.sv.m_a_targets.shift]
    @target_battler = N03.get_targets(@move_data[3], @battler) if @move_data[3] < 0
    set_move
    return if @move_data[16] == ""
    weapon_data = N03::ACTION[@move_data[16]]
    return if weapon_data == nil
    @weapon_data = weapon_data.dup
    set_graphics
    set_ox
    set_weapon_move
    end
    #--------------------------------------------------------------------------
    # ● 武器画像を取得
    #--------------------------------------------------------------------------
    def set_graphics
    # 武器に依存しない画像設定がある場
    if @weapon_data[13] != ""
    self.bitmap = Cache.character(@weapon_data[13]).dup
    @weapon_width = self.bitmap.width
    @weapon_height = self.bitmap.height
    return
    end
    # 武器を取得
    weapon = @battler.weapons[0]
    # 逆手装備を取得
    if @weapon_data[10]
    weapon = nil
    for armor in @battler.armors do break weapon = armor if armor.is_a?(RPG::Armor) && armor.etype_id == 1 end
    weapon = @battler.weapons[1] if !weapon
    end
    # 武器がなければ処理をキャンセル
    return if weapon == nil
    # インデックスを取得
    file_index = @weapon_data[12]
    # アイコンを利用するなら
    if @weapon_data[1] == 0
    icon_index = weapon.icon_index
    self.bitmap = Cache.system("Iconset" + file_index).dup
    self.src_rect.set(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    @weapon_width = @weapon_height = 24
    # 独自画像指定
    else
    file_name = @battler.sv.weapon_graphic(weapon.id, weapon.wtype_id) if weapon.is_a?(RPG::Weapon)
    file_name = @battler.sv.shield_graphic(weapon.id, weapon.atype_id) if weapon.is_a?(RPG::Armor)
    self.bitmap = Cache.character(file_name + file_index).dup
    @weapon_width = self.bitmap.width
    @weapon_height = self.bitmap.height
    return if @weapon_data[1] == 1
    # 2003仕様の武器アニメ
    @weapon_width /= @battler.sv.max_pattern[0]
    end
    end
    #--------------------------------------------------------------------------
    # ● 画像の原点を取得
    #--------------------------------------------------------------------------
    def set_ox
    # 反転時は設定を逆に
    if @mirror
    case @weapon_data[6]
    when 1 ; @weapon_data[6] = 2 # 左上→右上に
    when 2 ; @weapon_data[6] = 1 # 右上→左上に
    when 3 ; @weapon_data[6] = 4 # 左下→右下に
    when 4 ; @weapon_data[6] = 3 # 右下→左下に
    end
    end
    # 原点を設定
    case @weapon_data[6]
    when 0 # 中心
    self.ox = @weapon_width / 2
    self.oy = @weapon_height / 2
    when 1 # 左上
    self.ox = 0
    self.oy = 0
    when 2 # 右上
    self.ox = @weapon_width
    self.oy = 0
    when 3 # 左下
    self.ox = 0
    self.oy = @weapon_height
    when 4 # 右下
    self.ox = @weapon_width
    self.oy = @weapon_height
    when 5 # バトラーと同じ
    self.ox = @weapon_width / 2
    self.oy = @weapon_height
    end
    end
    #--------------------------------------------------------------------------
    # ● バトラーの座標を取得
    #--------------------------------------------------------------------------
    def set_battler_position
    @position_x = @battler.sv.x + @weapon_data[3][0] * N03.mirror_num(@mirror) * 100
    @position_y = (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.c - @battler.sv.oy_adjust) + @weapon_data[3][1] * 100
    reset_position
    end
    #--------------------------------------------------------------------------
    # ● 座標を初期化
    #--------------------------------------------------------------------------
    def reset_position
    @real_x = @position_x / 100
    @real_y = @position_y / 100
    @real_zoom_x = 1
    @real_zoom_y = 1
    end
    #--------------------------------------------------------------------------
    # ● 戦闘アニメを表示
    #--------------------------------------------------------------------------
    def set_animation(anime_id)
    return if $data_animations[anime_id] == nil
    @anime_position = $data_animations[anime_id].position
    @horming = true
    @horming = false if @anime_position == 3
    @anime_camera_zoom = true
    @anime_no_mirror = false
    start_animation($data_animations[anime_id], @mirror)
    timings = $data_animations[anime_id].timings
    end
    #--------------------------------------------------------------------------
    # ● ヒット時の戦闘アニメ実行
    #--------------------------------------------------------------------------
    def set_hit_animation(position_data, hit_anime_id, target)
    return if $data_animations[hit_anime_id] == nil
    @real_x = position_data[0]
    @real_y = position_data[1]
    @position_x = position_data[0] * 100
    @position_y = position_data[1] * 100
    self.z = position_data[2]
    @z_plus = 1000
    @action_end = false
    @horming = true
    set_animation(hit_anime_id)
    @anime_time = $data_animations[hit_anime_id].frame_max * 4
    @timing_targets = [target]
    @move_time = @hit_anime_id = 0
    @weapon_data = []
    end
    #--------------------------------------------------------------------------
    # ● タイミングバトラー追加
    #--------------------------------------------------------------------------
    def timing_battler_set(target)
    @timing_targets.push(target)
    end
    #--------------------------------------------------------------------------
    # ● 武器の動きを取得
    #--------------------------------------------------------------------------
    def set_weapon_move
    # 開始位置を取得
    set_battler_position if @move_time == 0
    @z_plus = 50 if @z_plus == 0 && @weapon_data[9]
    self.z = @battler.sv.z + @z_plus
    # 反転処理
    @mirror = !@mirror if @weapon_data[7]
    self.mirror = @mirror
    # 更新パターンをセット
    set_pattern
    @max_pattern = 2 if @max_pattern == 1
    # 動きを計算
    @weapon_move_data = []
    @weapon_angle_data = []
    @weapon_zoom_data = []
    num = N03.mirror_num(@mirror)
    for i in 0...@max_pattern
    move_data_x = @weapon_data[2][0] * num * 100 * i / (@max_pattern - 1)
    move_data_y = @weapon_data[2][1] * 100 * i / (@max_pattern - 1)
    move_angle = @weapon_data[4] * num + (@weapon_data[5] * num - @weapon_data[4] * num) * i / (@max_pattern - 1)
    move_zoom_x = 1 + (@weapon_data[8][0] - 1) * i / (@max_pattern - 1)
    move_zoom_y = 1 + (@weapon_data[8][1] - 1) * i / (@max_pattern - 1)
    @weapon_move_data.push([move_data_x, move_data_y])
    @weapon_angle_data.push(move_angle)
    @weapon_zoom_data.push([move_zoom_x, move_zoom_y])
    end
    end
    #--------------------------------------------------------------------------
    # ● 更新パターン
    #--------------------------------------------------------------------------
    def set_pattern
    if @weapon_data[11] == -1
    return @max_pattern = @battler.sv.max_pattern[0] if @battler.sv.pattern_type != 0
    @count = @battler.sv.pattern_time
    @max_count = @battler.sv.pattern_time
    @max_pattern = @battler.sv.max_pattern[0]
    @repeat = false
    else
    @count = @weapon_data[11][0]
    @max_count = @weapon_data[11][0]
    @max_pattern = @weapon_data[11][1]
    @repeat = @weapon_data[11][2]
    end
    @pattern = 0
    end
    #--------------------------------------------------------------------------
    # ● 移動実行
    #--------------------------------------------------------------------------
    def set_move
    # 戦闘アニメを取得
    set_animation(@move_data[1][0]) if $data_animations[@move_data[1][0]] != nil && $data_animations[@move_data[1][0]].position != 3
    @anime_camera_zoom = @move_data[13]
    @loop = @move_data[14]
    @loop = false if @move_data[1][0] == 0
    @anime_no_mirror = @move_data[15]
    @se_flag = @move_data[17]
    # 開始位置を取得
    start_position
    @z_plus = 1000 if @move_data[9]
    # ターゲットバトラー画像にこのアニ のSEとタイミング設定を反映させる
    @timing_targets = @target_battler
    # 座標計算
    @move_x = @move_data[5][0] * 100 * N03.mirror_num(@mirror)
    @move_y = @move_data[5][1] * 100
    # 時間計算か速度計算か
    @distanse_move = true if @move_data[6] > 0
    @move_time = @move_data[6].abs
    # 時間0の場合、アニメが設定されてい ばアニメ表示時間に合わせる
    if @move_time == 0
    @move_time = $data_animations[@move_data[1][0]].frame_max * 4 if $data_animations[@move_data[1][0]]
    @move_time = 1 if !$data_animations[@move_data[1][0]]
    @distanse_move = false
    end
    # 貫通タイプの場合
    @through = true if @move_data[7] == 1
    @auto_through_flag = false
    @auto_through_flag = true if @move_data[7] == 0
    # ターゲット座標計算
    if @target_battler == nil
    @target_x = @move_x * 100
    @target_x = (Graphics.width - @move_x) * 100 if @mirror
    @target_y = @move_y * 100
    else
    move_data_set
    end
    # ターゲットに到達するまでの時間を 算
    @move_time = distanse_calculation(@move_time, @target_x, @target_y)
    # 円軌道計算
    orbit
    # バトラーのウエイト設定
    @battler.sv.wait = @move_time - 1 if @move_data[10][0]
    @move_horming = @move_data[12]
    end
    #--------------------------------------------------------------------------
    # ● 速度を時間に変換
    #--------------------------------------------------------------------------
    def distanse_calculation(time, target_x, target_y)
    return time if !@distanse_move
    distanse_x = @position_x - @target_x
    distanse_x = @target_x - @position_x if @target_x > @position_x
    distanse_y = @position_y - @target_y
    distanse_y = @target_y - @position_y if @target_y > @position_y
    distanse = [distanse_x, distanse_y].max
    return distanse / (time * 100) + 1
    end
    #--------------------------------------------------------------------------
    # ● 移動目標の更新
    #--------------------------------------------------------------------------
    def move_data_set
    return if @target_battler == nil
    position = N03.get_targets_position(@target_battler, true, @anime_position)
    @target_x = position[0] + @move_x
    @target_y = position[1] - position[2] + @move_y
    end
    #--------------------------------------------------------------------------
    # ● 開始位置を計算
    #--------------------------------------------------------------------------
    def start_position
    starter = [@battler.sv.m_a_starter.shift]
    starter = N03.get_targets(@move_data[2], @battler) if @move_data[2] < 0
    position = [0, 0]
    position = N03.get_targets_position(starter, true, @anime_position) if starter != nil
    @position_x = position[0] + @move_data[4][0] * 100
    @position_y = position[1] + position[2] + @move_data[4][1] * 100
    @position_z = @position_y
    end
    #--------------------------------------------------------------------------
    # ● 円軌道計算
    #--------------------------------------------------------------------------
    def orbit
    orbit_data = @move_data[8].dup
    orbit_data[0] *= 100
    orbit_data[1] *= 100
    orbit_d = []
    for i in 0...@move_time / 2
    @orbit[i] = orbit_data[0]
    orbit_data[0] /= 2
    orbit_d[i] = orbit_data[1]
    orbit_data[1] /= 2
    end
    @orbit = @orbit + orbit_d.reverse!
    @orbit.reverse!
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def update
    update_hit_anime if @anime_time != 0
    update_move if @move_time != 0
    update_weapon_move if @weapon_data != []
    update_position
    update_color
    self.visible = @battler.sv.weapon_visible
    super
    end
    #--------------------------------------------------------------------------
    # ● ヒット時の戦闘アニメ
    #--------------------------------------------------------------------------
    def update_hit_anime
    @anime_time -= 1
    @action_end = true if @anime_time == 0
    end
    #--------------------------------------------------------------------------
    # ● 移動の更新
    #--------------------------------------------------------------------------
    def update_move
    move_data_set if @move_horming && !@hit_position
    through_set(@move_time, @target_x, @target_y) if @move_time == 1 && !@hit_position
    @o += @orbit[@move_time - 1] if @orbit[@move_time - 1] != nil
    @position_x = (@position_x * (@move_time - 1) + @target_x) / @move_time
    @position_y = (@position_y * (@move_time - 1) + @target_y) / @move_time + @o
    reset_position
    set_animation(@move_data[1][0]) if @loop && !animation?
    @move_time -= 1
    return if @move_time != 0
    @action_end = true if !@action_end_cancel
    end
    #--------------------------------------------------------------------------
    # ● 武器の動きを更新
    #--------------------------------------------------------------------------
    def update_weapon_move
    pattern = update_pattern
    set_battler_position if @move_time == 0 && !@action_end_cancel
    @real_x = @position_x / 100 + @weapon_move_data[pattern][0] / 100
    @real_y = @position_y / 100 + @weapon_move_data[pattern][1] / 100
    @real_zoom_x = @weapon_zoom_data[pattern][0]
    @real_zoom_y = @weapon_zoom_data[pattern][1]
    self.angle = @weapon_angle_data[pattern]
    self.src_rect.set(@weapon_width * pattern, 0, @weapon_width, @weapon_height) if @weapon_data[1] == 2
    end
    #--------------------------------------------------------------------------
    # ● パターンを更新
    #--------------------------------------------------------------------------
    def update_pattern
    return @battler.sv.pattern_w if @count == nil
    @count -= 1
    return @pattern if @count != 0
    @count = @max_count
    @pattern += 1
    if !@repeat && @pattern == @max_pattern
    @pattern = @max_pattern - 1
    elsif @pattern == @max_pattern
    @pattern = 0
    end
    return @pattern
    end
    #--------------------------------------------------------------------------
    # ● 座標を更新
    #--------------------------------------------------------------------------
    def update_position
    self.x = (@real_x - $sv_camera.x) * $sv_camera.convert / 1000
    self.y = (@real_y - $sv_camera.y) * $sv_camera.convert / 1000
    self.x += $sv_camera.sx / 100 unless @battler.sv.h != 0 && @weapon_data != []
    self.y += $sv_camera.sy / 100 unless @battler.sv.h != 0 && @weapon_data != []
    self.z = @battler.sv.z + @z_plus - 10
    self.zoom_x = @real_zoom_x * $sv_camera.zoom
    self.zoom_y = @real_zoom_y * $sv_camera.zoom
    self.opacity = @battler.sv.opacity if @battler.sv.opacity_data[4]
    end
    #--------------------------------------------------------------------------
    # ● 貫通の処理
    #--------------------------------------------------------------------------
    def through_set(time, target_x, target_y)
    @hit_anime_id = N03.get_attack_anime_id(@move_data[1][1], @battler)
    @battler.sv.wait = N03.get_anime_time(@hit_anime_id) if @move_data[10][1]
    moving_x = (target_x / 100 - @position_x / 100) / time
    moving_y = (target_y / 100 - @position_y / 100) / time
    goal_x = $sv_camera.max_left - 100 if moving_x < 0
    goal_x = Graphics.width + $sv_camera.max_right + 100 if moving_x > 0
    goal_y = $sv_camera.max_top - 100 if moving_y < 0
    goal_y = Graphics.height + $sv_camera.max_bottom + 100 if moving_y > 0
    if goal_x == nil && goal_y == nil
    time = 0
    reset_position
    else
    time = move_calculation(moving_x, moving_y, goal_x, goal_y)
    end
    target_x = @position_x + moving_x * time * 100
    target_y = @position_y + moving_y * time * 100
    @pre_data = [time, target_x, target_y]
    @battler.sv.m_a_data.push([@move_data[11], @target_battler, @index, @auto_through_flag, []])
    @action_end_cancel = true
    @hit_position = [@real_x, @real_y, self.z]
    end
    #--------------------------------------------------------------------------
    # ● 到達時間試算
    #--------------------------------------------------------------------------
    def move_calculation(moving_x, moving_y, goal_x, goal_y)
    move_x = @position_x / 100
    move_y = @position_y / 100
    time = 0
    loop do
    move_x += moving_x
    move_y += moving_y
    time += 1
    return time if moving_x < 0 && move_x < goal_x
    return time if moving_x > 0 && move_x > goal_x
    return time if moving_y < 0 && move_y < goal_y
    return time if moving_y > 0 && move_y > goal_y
    end
    end
    #--------------------------------------------------------------------------
    # ● ミス時に消える処理から貫通処理に 換
    #--------------------------------------------------------------------------
    def through_change
    @action_end_cancel = false
    @through = true
    @move_time = @pre_data[0]
    @target_x = @pre_data[1]
    @target_y = @pre_data[2]
    @pre_data = nil
    end
    #--------------------------------------------------------------------------
    # ● SE とフラッシュのタイミング処理
    #--------------------------------------------------------------------------
    def animation_process_timing(timing)
    return if !@timing_targets
    se_flag = true
    se_flag = @se_flag if @se_flag != nil
    for target in @timing_targets
    target.sv.timing.push([se_flag, timing.dup])
    se_flag = false if @animation.position == 3
    end
    end
    #--------------------------------------------------------------------------
    # ● 色調の更新
    #--------------------------------------------------------------------------
    def update_color
    return if @battler.sv.color == []
    self.color.set(@battler.sv.color[0], @battler.sv.color[1], @battler.sv.color[2], @battler.sv.color[3])
    end
    #--------------------------------------------------------------------------
    # ● 解放
    #--------------------------------------------------------------------------
    def dispose
    super
    self.bitmap.dispose if self.bitmap != nil
    end
    end

    #================================================= =============================
    # ■ Sprite_Battle_Picture
    #------------------------------------------------------------------------------
    #  ピクチャ表示用のスプライトです
    #================================================= =============================
    class Sprite_Battle_Picture < Sprite
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数 
    #--------------------------------------------------------------------------
    attr_accessor :action_end # 終了フラグ
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    def initialize(viewport = nil)
    super(viewport)
    @action_end = false
    self.ox = 0
    end
    #--------------------------------------------------------------------------
    # ● セット
    #--------------------------------------------------------------------------
    def set(battler)
    @battler = battler
    @data = @battler.sv.effect_data.shift
    @time = @data[4]
    @mirror = $sv_camera.mirror
    @mirror = false if !@data[8]
    self.opacity = @data[6][0]
    @s_x = @data[2][0] if @data[2] != []
    @s_x = Graphics.width - @data[2][0] if @data[2] != [] && @mirror
    @s_y = @data[2][1] if @data[2] != []
    @e_x = @data[3][0] if @data[3] != []
    @e_x = Graphics.width - @data[3][0] if @data[3] != [] && @mirror
    @e_y = @data[3][1] if @data[3] != []
    @s_x = self.x if @data[2] == []
    @s_y = self.y if @data[2] == []
    @e_x = self.x if @data[3] == []
    @e_y = self.y if @data[3] == []
    self.x = @s_x
    self.y = @s_y
    return @action_end = true if @time == 0
    @move_x = (@e_x * 1.0 - @s_x) / @time
    @move_y = (@e_y * 1.0 - @s_y) / @time
    self.z = @data[5]
    return set_plane(battler) if @data[7] != []
    self.bitmap = Cache.picture(@data[9]) if !bitmap or @data[9] != ""
    return @action_end = true if !bitmap
    self.mirror = @mirror
    self.ox = self.bitmap.width if @mirror
    end
    #--------------------------------------------------------------------------
    # ● プレーン移行
    #--------------------------------------------------------------------------
    def set_plane(battler)
    @viewport = Viewport.new(@data[2][0],@data[2][1],@data[7][0],@data[7][1]) if !@viewport
    viewport = @viewport
    @plane = Plane.new(viewport) if !@plane
    @plane.bitmap = Cache.picture(@data[9]) if !@plane.bitmap or @data[9] != ""
    return @action_end = true if !@plane.bitmap
    @plane.ox = @data[7][0]
    @plane.oy = @data[7][1]
    @plane.opacity = @data[6][0]
    @move_x = @remain_move[0] if @data[2] == @data[3]
    @move_y = @remain_move[1] if @data[2] == @data[3]
    @remain_move = [@move_x, @move_y]
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def update
    @action_end = true if !@battler.sv.picture
    return if @time == 0
    return if @action_end
    @time -= 1
    return plane_update if @plane
    super
    self.x += @move_x
    self.y += @move_y
    self.opacity += @data[6][1]
    return if @time != 1
    self.x = @e_x
    self.y = @e_y
    @time = 0
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def plane_update
    @plane.ox += @move_x
    @plane.oy += @move_y
    @plane.opacity += @data[6][1]
    @time = @data[4] if @time == 0
    end
    #--------------------------------------------------------------------------
    # ● 解放
    #--------------------------------------------------------------------------
    def dispose
    bitmap.dispose if bitmap
    @plane.dispose if @plane
    @viewport.dispose if @viewport
    super
    end
    end

    #================================================= =============================
    # ■ Sprite_Back_Picture
    #------------------------------------------------------------------------------
    #  周期ピクチャ用のスプライトです
    #================================================= =============================
    class Sprite_Back_Picture < Plane
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数 
    #--------------------------------------------------------------------------
    attr_accessor :action_end # 終了フラグ
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    def initialize(viewport = nil, index)
    super(viewport)
    @index = index
    @real_x = 0
    @real_y = 0
    @real_opacity = 0
    @move_x = 0
    @move_y = 0
    @move_opacity = 0
    @time = 0
    @switche = 0
    @action_end = false
    end
    #--------------------------------------------------------------------------
    # ● セットアップ
    #--------------------------------------------------------------------------
    def setup(data)
    self.bitmap = Cache.picture(data[9])
    self.z = data[6]
    @switche = data[1]
    mirror = $sv_camera.mirror
    mirror = false if !data[8]
    @move_x = data[3][0]
    @move_x *= -1 if mirror
    @move_y = data[3][1]
    @time = data[4]
    @time = -1 if @time == 0
    @real_opacity = (data[5][0] + 1) * 100
    @move_opacity = data[5][1]
    @start_opacity = data[5][0]
    @shake_ok = data[7]
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def update
    update_picture if @time != 0
    self.ox = $sv_camera.x - @real_x
    self.oy = $sv_camera.y - @real_y
    if @shake_ok
    self.ox -= $sv_camera.sx / 100
    self.oy -= $sv_camera.sy / 100
    end
    self.ox *= $sv_camera.zoom
    self.oy *= $sv_camera.zoom
    self.zoom_x = @zoom_x * $sv_camera.zoom
    self.zoom_y = @zoom_y * $sv_camera.zoom
    self.opacity = @real_opacity / 100
    @move_opacity *= -1 if self.opacity == 255 or self.opacity <= @start_opacity
    @switche
    @action_end = true if @switche > 0 && !$game_switches[@switche]
    @action_end = true if @switche < 0 && !$sv_camera.switches[@switche.abs]
    end
    #--------------------------------------------------------------------------
    # ● ピクチャの更新
    #--------------------------------------------------------------------------
    def update_picture
    @real_x += @move_x / 100
    @real_y += @move_y / 100
    @real_x = 0 if @real_x >= self.bitmap.width or @real_x <= -self.bitmap.width
    @real_y = 0 if @real_y >= self.bitmap.height or @real_y <= -self.bitmap.height
    @zoom_x = 1
    @zoom_y = 1
    @real_opacity += @move_opacity
    @time -= 1
    @time = -1 if @time < -100
    end
    end

    #================================================= =============================
    # ■ Sprite_Back_Picture
    #------------------------------------------------------------------------------
    #  ダメージ表示のスプライトです。
    #================================================= =============================
    class Sprite_Damage < Sprite
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数 
    #--------------------------------------------------------------------------
    attr_reader :action_end # POP終了フラグ
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    def initialize(viewport = nil, battler)
    super(viewport)
    @battler = battler
    @time = 0
    return @action_end = true if !@battler
    @direction = -1
    @direction *= -1 if @battler.actor?
    @direction *= -1 if $sv_camera.mirror
    set_state
    set_damage
    update
    end
    #--------------------------------------------------------------------------
    # ● ステート表示
    #--------------------------------------------------------------------------
    def set_state
    return if !N03::STATE_POP
    states = @battler.result.added_state_objects
    states.delete($data_states[@battler.death_state_id]) if @battler.result.hp_damage != 0
    return if states == []
    return if @battler.sv.add_state == @battler.result.added_state_objects
    @battler.sv.add_state = states.dup
    @st = []
    @st_base = []
    for i in 0...states.size
    @st[i] = Sprite.new
    bitmap_state(@st[i], states[i])
    @st_base[i] = []
    @st_base[i][0] = @direction * (-20 + 5 * i) + @battler.sv.x / 100
    @st_base[i][1] = -40 - @state_height * i + (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.oy_adjust)/ 100
    @st[i].z = 1000 + i
    @st[i].opacity = 0
    end
    @time = @pop_time = 80
    end
    #--------------------------------------------------------------------------
    # ● ステート画像
    #--------------------------------------------------------------------------
    def bitmap_state(state, state_object)
    name = state_object.name
    state.bitmap = Cache.system("Iconset").dup
    state.src_rect.set(state_object.icon_index % 16 * 24, state_object.icon_index / 16 * 24, 24, 24)
    @state_height = 24
    end
    #--------------------------------------------------------------------------
    # ● ダメージ表示
    #--------------------------------------------------------------------------
    def hit_count
    for i in 0...@battler.sv.hit.size
    if @battler.sv.hit[i] == nil
    @hit = i
    return @battler.sv.hit[i] = @hit
    end
    end
    @hit = @battler.sv.hit.size
    @battler.sv.hit.push(@hit)
    end
    #--------------------------------------------------------------------------
    # ● ダメージ表示
    #--------------------------------------------------------------------------
    def set_damage
    return @action_end = true if !N03:AMAGE_POP
    damage = @battler.result.hp_damage if @battler.result.hp_damage != 0
    damage = @battler.result.hp_drain if @battler.result.hp_drain != 0
    damage = @battler.result.mp_damage if @battler.result.mp_damage != 0
    damage = @battler.result.mp_drain if @battler.result.mp_drain != 0
    damage = @battler.result.tp_damage if @battler.result.tp_damage != 0
    if !damage or damage == 0
    @action_end = true if @st == nil
    return # ステートだけPOPする設定を考慮して@a ction_endは返さない
    end
    hit_count
    #@hit = @battler.sv.hit
    #@battler.sv.hit += 1 if damage != 0
    file = N03:AMAGE_PLUS if damage > 0
    file = N03:AMAGE_MINUS if damage < 0
    add_file = N03:AMAGE_MP if @battler.result.mp_damage != 0
    add_file = N03:AMAGE_TP if @battler.result.tp_damage != 0
    adjust_x = N03:AMAGE_ADJUST
    @num = []
    @num_base = []
    damage = damage.abs
    max_num = damage.to_s.size
    max_num += 1 if add_file != nil
    for i in 0...max_num
    @num[i] = Sprite.new
    if add_file != nil && i == max_num - 1
    @num[i].bitmap = Cache.system(add_file)
    cw = (damage % (10 * 10 ** i))/(10 ** i)
    sw = 0 if sw == nil
    else
    @num[i].bitmap = Cache.system(file)
    cw = (damage % (10 * 10 ** i))/(10 ** i)
    sw = @num[i].bitmap.width / 10
    @num[i].src_rect.set(cw * sw, 0, sw, @num[i].bitmap.height)
    end
    @num_base[i] = []
    @num_base[i][0] = (sw + adjust_x) * i * -1 + (@battler.sv.x / 100)
    @num_base[i][1] = -(@num[i].bitmap.height / 3) - i * 2 - @hit * 2 + (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.oy_adjust)/ 100
    @num_base[i][0] -= @num[i].bitmap.width / 2 - adjust_x if add_file != nil && i == max_num - 1
    @num[i].z = 1000 + i + @hit * 10
    end
    @time = @pop_time = 80
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def update
    return if @time == 0
    for i in 0...@st.size do update_state_move(@st[i], i) end if @st != nil
    for i in 0...@num.size do update_num_move(@num[i], i) end if @num != nil
    @time -= 1
    @action_end = true if @time == 0
    end
    #--------------------------------------------------------------------------
    # ● ステート画像の更新
    #--------------------------------------------------------------------------
    def update_state_move(state, index)
    min = @pop_time - index * 2
    case @time
    when min-15..min
    @st_base[index][0] += @direction
    state.opacity += 25
    when min-80..min-50
    @st_base[index][0] += @direction
    state.opacity -= 25
    end
    state.x = (@st_base[index][0] - $sv_camera.x) * $sv_camera.zoom
    state.y = (@st_base[index][1] - $sv_camera.y) * $sv_camera.zoom
    end
    #--------------------------------------------------------------------------
    # ● 数値の更新
    #--------------------------------------------------------------------------
    def update_num_move(num, index)
    min = @pop_time - index * 2
    case @time
    when min-1..min
    @num_base[index][0] += @direction * @hit
    @num_base[index][1] -= 5 + @hit * 2
    when min-3..min-2
    @num_base[index][0] += @direction * @hit
    @num_base[index][1] -= 4 + @hit * 2
    when min-6..min-4
    @num_base[index][0] += @direction
    @num_base[index][1] -= 3 + @hit * 2
    when min-14..min-7
    @num_base[index][0] += @direction
    @num_base[index][1] += 2
    when min-17..min-15
    @num_base[index][1] -= 2 + @hit * 2
    when min-23..min-18
    @num_base[index][1] += 1
    when min-27..min-24
    @num_base[index][1] -= 1
    when min-30..min-28
    @num_base[index][1] += 1
    when min-33..min-31
    @num_base[index][1] -= 1
    when min-36..min-34
    @num_base[index][1] += 1
    end
    num.x = (@num_base[index][0] - $sv_camera.x) * $sv_camera.zoom
    num.y = (@num_base[index][1] - $sv_camera.y) * $sv_camera.zoom
    num.opacity = 256 - (12 - @time) * 32
    num.visible = false if @time == 0
    end
    #--------------------------------------------------------------------------
    # ● 解放
    #--------------------------------------------------------------------------
    def dispose
    @battler.sv.hit[@hit] = nil if @hit
    bitmap.dispose if bitmap
    for i in 0...@num.size do @num[i].dispose end if @num != nil
    for i in 0...@st.size do @st[i].dispose end if @st != nil
    super
    end
    end

    #================================================= =============================
    # ■ Window_Skill_name
    #------------------------------------------------------------------------------
    #  スキル名を表示するウィンドウで 。
    #================================================= =============================
    class Window_Skill_name < Window_Base
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    def initialize(text)
    super(0, 0, Graphics.width, line_height + standard_padding * 2)
    draw_text(4, 0, Graphics.width - 64, line_height,text, 1)
    end
    end

    #================================================= =============================
    # ■ Spriteset_Sideview
    #------------------------------------------------------------------------------
    #  サイドビュー独自のスプライトを とめたクラスです。
    #================================================= =============================
    class Spriteset_Sideview
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    def initialize(viewport)
    @viewport = viewport
    @weapons = []
    @pictures = []
    @back_pic = []
    @damage = []
    $sv_camera.setup
    N03.camera(nil, N03::BATTLE_CAMERA["ターン開始前"].dup)
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def update
    update_battler_data
    update_damage
    update_pictures
    update_back_pic
    update_weapons
    end
    #--------------------------------------------------------------------------
    # ● バトラーデータの更新
    #--------------------------------------------------------------------------
    def update_battler_data
    for battler in $game_party.battle_members + $game_troop.members
    weapon_end(battler) if battler.sv.weapon_end
    next if battler.sv.effect_data == []
    for effect_data in battler.sv.effect_data do set_effects(battler, effect_data) end
    end
    end
    #--------------------------------------------------------------------------
    # ● ダメージ画像の更新
    #--------------------------------------------------------------------------
    def update_damage
    for i in 0...@damage.size
    next if @damage[i] == nil
    @damage[i].update if @damage[i] != nil
    next if !@damage[i].action_end
    @damage[i].dispose
    @damage[i] = nil
    end
    end
    #--------------------------------------------------------------------------
    # ● ピクチャアクションの更新
    #--------------------------------------------------------------------------
    def update_pictures
    for i in 0...@pictures.size
    next if @pictures[i] == nil
    @pictures[i].update if @pictures[i] != nil
    next if !@pictures[i].action_end
    @pictures[i].dispose
    @pictures[i] = nil
    end
    end
    #--------------------------------------------------------------------------
    # ● 周期ピクチャの更新
    #--------------------------------------------------------------------------
    def update_back_pic
    set_back_pic if $sv_camera.program_picture != []
    for i in 0...@back_pic.size
    next if @back_pic[i] == nil
    @back_pic[i].update if @back_pic[i] != nil
    next if !@back_pic[i].action_end
    @back_pic[i].dispose
    @back_pic[i] = nil
    end
    end
    #--------------------------------------------------------------------------
    # ● 武器アクションの更新
    #--------------------------------------------------------------------------
    def update_weapons
    for i in 0...@weapons.size
    next if @weapons[i] == nil
    @weapons[i].update if @weapons[i] != nil
    next if !@weapons[i].action_end
    @weapons[i].dispose
    @weapons[i] = nil
    end
    end
    #--------------------------------------------------------------------------
    # ● ダメージ実行
    #--------------------------------------------------------------------------
    def set_damage_pop(target)
    for i in 0...@damage.size
    next if @damage[i] != nil
    return @damage[i] = Sprite_Damage.new(@viewport, target)
    end
    @damage.push(Sprite_Damage.new(@viewport, target))
    end
    #--------------------------------------------------------------------------
    # ● 周期ピクチャ実行
    #--------------------------------------------------------------------------
    def set_back_pic
    for data in $sv_camera.program_picture
    if @back_pic[data[2]] != nil
    @back_pic[data[2]].dispose
    @back_pic[data[2]] = nil
    end
    @back_pic[data[2]] = Sprite_Back_Picture.new(@viewport, data[2])
    @back_pic[data[2]].setup(data)
    end
    $sv_camera.program_picture = []
    end
    #--------------------------------------------------------------------------
    # ● エフェクト開始
    #--------------------------------------------------------------------------
    def set_effects(battler, effect_data)
    case effect_data[0]
    when "pic" ; set_pictures(battler, effect_data)
    when "wp" ; set_weapons(battler, true)
    when "m_a" ; set_weapons(battler, false)
    end
    end
    #--------------------------------------------------------------------------
    # ● ピクチャアクション実行
    #--------------------------------------------------------------------------
    def set_pictures(battler, effect_data)
    @pictures[effect_data[1]] = Sprite_Battle_Picture.new if @pictures[effect_data[1]] == nil
    @pictures[effect_data[1]].set(battler)
    end
    #--------------------------------------------------------------------------
    # ● 武器アクション実行
    #--------------------------------------------------------------------------
    def set_weapons(battler, weapon_flag, test = true)
    for i in 0...@weapons.size
    next if @weapons[i] != nil
    @weapons[i] = Sprite_Weapon.new(@viewport, i, battler)
    battler.sv.weapon_index.push(i) if weapon_flag
    return i
    end
    @weapons.push(Sprite_Weapon.new(@viewport, @weapons.size, battler))
    battler.sv.weapon_index.push(@weapons.size - 1) if weapon_flag
    return @weapons.size - 1
    end
    #--------------------------------------------------------------------------
    # ● バトラーの武器アクション終了
    #--------------------------------------------------------------------------
    def weapon_end(battler)
    battler.sv.weapon_end = false
    for index in battler.sv.weapon_index
    weapon_index = battler.sv.weapon_index.shift
    @weapons[weapon_index].dispose if @weapons[weapon_index] != nil
    @weapons[weapon_index] = nil
    end
    battler.sv.weapon_index.compact!
    end
    #--------------------------------------------------------------------------
    # ● ヒット時の戦闘アニメ実行
    #--------------------------------------------------------------------------
    def set_hit_animation(battler, weapon_index, hit_targets, miss)
    weapon = @weapons[weapon_index]
    for target in hit_targets
    next @weapons[@hit_index].timing_battler_set(target) if @hit_index != nil
    @hit_index = set_weapons(battler, false, false)
    @weapons[@hit_index].set_hit_animation(weapon.hit_position, weapon.hit_anime_id, target)
    end
    @hit_index = nil
    if !weapon.through && !miss
    @weapons[weapon_index].dispose
    @weapons[weapon_index] = nil
    else
    @weapons[weapon_index].through_change
    end
    end
    #--------------------------------------------------------------------------
    # ● サイドビューデータの初期化
    #--------------------------------------------------------------------------
    def reset_sideview
    $sv_camera.reset
    for member in $game_troop.members + $game_party.battle_members do member.sv.reset end
    end
    #--------------------------------------------------------------------------
    # ● 解放
    #--------------------------------------------------------------------------
    def dispose
    dispose_effects(@weapons)
    dispose_effects(@pictures)
    dispose_effects(@back_pic)
    dispose_effects(@damage)
    reset_sideview
    end
    #--------------------------------------------------------------------------
    # ● エフェクト画像の解放
    #--------------------------------------------------------------------------
    def dispose_effects(effects)
    for i in 0...effects.size
    effects[i].dispose if effects[i] != nil
    effects[i] = nil
    end
    end
    end


    #================================================= =============================
    # ■ Sprite_Battle_Back
    #------------------------------------------------------------------------------
    #  戦闘背景用のスプライトです。
    #================================================= =============================
    class Sprite_Battle_Back < Plane
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    def initialize(viewport = nil, index, battleback_name)
    super(viewport)
    @index = index
    if @index == 1
    data = N03::FLOOR1_DATA[battleback_name]
    data = N03::FLOOR1_DATA["全Battlebacks1"] if data == nil
    elsif @index == 2
    data = N03::FLOOR2_DATA[battleback_name]
    data = N03::FLOOR2_DATA["全Battlebacks2"] if data == nil
    end
    data = data.dup
    @adjust_position = data[0]
    @zoom_x = data[1][0] / 100.0
    @zoom_y = data[1][1] / 100.0
    @shake_on = data[2]
    $game_switches[data[3]] = true if data[3] > 0
    $sv_camera.switches[data[3].abs] = true if data[3] < 0
    reset_scroll
    reset_back_data(battleback_name)
    end
    #--------------------------------------------------------------------------
    # ● 背景スクロールを初期化
    #--------------------------------------------------------------------------
    def reset_scroll
    @scroll_x = 0
    @scroll_y = 0
    @move_x = 0
    @move_y = 0
    end
    #--------------------------------------------------------------------------
    # ● 背景データを初期化
    #--------------------------------------------------------------------------
    def reset_back_data(battleback_name)
    @back_data = []
    @active_data = ["scroll",0, @move_x, @move_y, false, battleback_name,""]
    start_back_data(@active_data)
    end
    #--------------------------------------------------------------------------
    # ● 背景画像のセッティング
    #--------------------------------------------------------------------------
    def set_graphics(new_bitmap)
    self.bitmap = new_bitmap
    @base_x = (self.bitmap.width * @zoom_x - Graphics.width) / 2 + @adjust_position[0]
    @base_y = (self.bitmap.height * @zoom_y - Graphics.height) / 2 + @adjust_position[1]
    # 限界座標を取得
    max_top = 0
    max_bottom = self.bitmap.height * @zoom_y - Graphics.height
    max_left = 0
    max_right = self.bitmap.width * @zoom_x - Graphics.width
    exist = true
    exist = false if self.bitmap.height == 32 && self.bitmap.width == 32
    $sv_camera.setting(@index, [max_top, max_bottom, max_left, max_right, @base_x, @base_y,exist])
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def update
    return if !bitmap
    update_back_data
    update_scroll unless @move_x == 0 && @move_y == 0
    update_color
    update_position
    update_back_adjust if @bt_back != nil
    create_back_adjust if @bt_back == nil && !@active_data[10] && @scroll_x == 0 && @scroll_y == 0
    end
    #--------------------------------------------------------------------------
    # ● 背景データを更新
    #--------------------------------------------------------------------------
    def update_back_data
    delete = true if @active_data[1] > 0 && !$game_switches[@active_data[1]]
    delete = true if @active_data[1] < 0 && !$sv_camera.switches[@active_data[1].abs]
    return if !delete
    for i in 0...@back_data.size
    @back_data[i] = nil if @back_data[i][1] > 0 && !$game_switches[@back_data[i][1]]
    @back_data[i] = nil if @back_data[i][1] < 0 && !$sv_camera.switches[@back_data[i][1].abs]
    end
    @back_data.compact!
    next_back_data
    end
    #--------------------------------------------------------------------------
    # ● 次の背景データをセット
    #--------------------------------------------------------------------------
    def next_back_data
    @back_data.delete(@active_data[11]) if @active_data[11] != nil
    @back_data.push(@active_data[11]) if @active_data[11] != nil
    @active_data = nil
    data = @back_data.pop
    @back_data = [@active_data] if @back_data.size == 0
    start_back_data(data)
    end
    #--------------------------------------------------------------------------
    # ● 背景データを実行
    #--------------------------------------------------------------------------
    def start_back_data(data)
    return if back_data_remain(data)
    bt_back_dispose
    pre_active_data = @active_data
    @active_data[8] = [@back_name, @move_x, @move_y, @scroll_x, @scroll_y] if @active_data != nil
    @back_data.push(@active_data) if @active_data != nil
    @active_data = data.dup
    @active_data[5] = @back_name if @active_data[5] == ""
    @active_data[9] = set_back_adjust if @active_data[9] == nil
    back_data_scroll_on if @active_data[8] == nil && @active_data[9][0] == false
    set_remain_back_data if @active_data[8] != nil
    create_back(@active_data[5]) if @active_data[9][0] == false
    create_back_adjust if @active_data[10]
    @active_data[11] = pre_active_data if pre_active_data && @active_data[7] == false
    end
    #--------------------------------------------------------------------------
    # ● 背景データの保留
    #--------------------------------------------------------------------------
    def back_data_remain(data)
    remain = false
    remain = true if data[6] != "" && @active_data != nil && @active_data[9] != nil && @active_data[9][0] != false
    remain = true if @active_data != nil && @active_data[7] == false
    return remain if !remain
    @remain = true
    @back_data.push(data)
    return remain
    end
    #--------------------------------------------------------------------------
    # ● 背景変更補正データをセット
    #--------------------------------------------------------------------------
    def set_back_adjust
    bt_adjust = []
    sign = -1
    if @active_data[6] == ""
    reset_scroll if @active_data[3][0] == 0 && @active_data[3][1] == 0
    bt_adjust = [false,false,0,0]
    return bt_adjust
    elsif @move_x != 0 or @active_data[3][0] != 0
    sign = 1 if @move_x < 0
    bt_adjust[0] = [self.bitmap.width * @zoom_x * sign, 0]
    bt_adjust[1] = [self.bitmap.width * @zoom_x * sign * 2, 0]
    elsif @move_y != 0 or @active_data[3][1] != 0
    sign = 1 if @move_y < 0
    bt_adjust[0] = [0, self.bitmap.height * @zoom_y * sign]
    bt_adjust[1] = [0, self.bitmap.height * @zoom_y * sign * 2]
    else
    reset_scroll if @active_data[3][0] == 0 && @active_data[3][1] == 0
    bt_adjust = [false,false,0,0]
    return bt_adjust
    end
    bt_adjust[2] = [bt_adjust[0][0], bt_adjust[0][1]]
    return bt_adjust
    end
    #--------------------------------------------------------------------------
    # ● 背景スクロールデータを実行
    #--------------------------------------------------------------------------
    def back_data_scroll_on
    mirror = $sv_camera.mirror
    mirror = false if !@active_data[4]
    @move_x = @active_data[3][0]
    @move_x *= -1 if mirror
    @move_y = @active_data[3][1]
    end
    #--------------------------------------------------------------------------
    # ● 保持している背景データを実行
    #--------------------------------------------------------------------------
    def set_remain_back_data
    return back_data_scroll_on if @move_x != 0 or @move_y != 0
    create_back(@active_data[8][0])
    @move_x = @active_data[8][1]
    @move_y = @active_data[8][2]
    @scroll_x = @active_data[8][3]
    @scroll_y = @active_data[8][4]
    end
    #--------------------------------------------------------------------------
    # ● 背景画像の作成
    #--------------------------------------------------------------------------
    def create_back(back_name)
    return if back_name == @back_name or back_name == ""
    self.bitmap = Cache.battleback1(back_name) if @index == 1
    self.bitmap = Cache.battleback2(back_name) if @index == 2
    @back_name = back_name
    end
    #--------------------------------------------------------------------------
    # ● 背景変更補正画像の作成
    #--------------------------------------------------------------------------
    def create_back_adjust
    return if @active_data[9][0] == false
    @active_data[10] = true
    mirror = $sv_camera.mirror
    mirror = false if !@active_data[4]
    @bt_back = []
    @bt_back[0] = Sprite.new(viewport)
    @bt_back[0].bitmap = Cache.battleback1(@active_data[6]) if @index == 1
    @bt_back[0].bitmap = Cache.battleback2(@active_data[6]) if @index == 2
    @bt_back[0].mirror = mirror
    @bt_back[1] = Sprite.new(viewport)
    @bt_back[1].bitmap = Cache.battleback1(@active_data[5]) if @index == 1
    @bt_back[1].bitmap = Cache.battleback2(@active_data[5]) if @index == 2
    @bt_back[1].mirror = mirror
    end
    #--------------------------------------------------------------------------
    # ● 背景スクロールの更新
    #--------------------------------------------------------------------------
    def update_scroll
    @scroll_x += @move_x
    @scroll_y += @move_y
    @scroll_x = 0 if @scroll_x / 100 >= self.bitmap.width * @zoom_x or @scroll_x / 100 <= -self.bitmap.width * @zoom_x
    @scroll_y = 0 if @scroll_y / 100 >= self.bitmap.height * @zoom_y or @scroll_y / 100 <= -self.bitmap.height * @zoom_y
    end
    #--------------------------------------------------------------------------
    # ● 色調変更の更新
    #--------------------------------------------------------------------------
    def update_color
    color_set if $sv_camera.color_set[@index] != nil
    return if @color_data == nil
    @color_data[4] -= 1
    if @color_data[4] == 0 && @color_data[5] != 0
    @color_data[4] = @color_data[5]
    @color_data[5] = 0
    @color_data[6] = [0,0,0,0]
    elsif @color_data[4] == 0
    @remain_color_data = @color_data
    return @color_data = nil
    end
    for i in 0..3
    @color_data[i] = (@color_data[i] * (@color_data[4] - 1) + @color_data[6][i]) / @color_data[4]
    end
    self.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3])
    end
    #--------------------------------------------------------------------------
    # ● 座標の更新
    #--------------------------------------------------------------------------
    def update_position
    self.ox = $sv_camera.x + @base_x - @scroll_x / 100
    self.oy = $sv_camera.y + @base_y - @scroll_y / 100
    self.ox -= $sv_camera.sx / 100 if @shake_on
    self.oy -= $sv_camera.sy / 100 if @shake_on
    self.zoom_x = @zoom_x * $sv_camera.zoom
    self.zoom_y = @zoom_y * $sv_camera.zoom
    self.ox *= $sv_camera.zoom
    self.oy *= $sv_camera.zoom
    self.z = @index * 10
    end
    #--------------------------------------------------------------------------
    # ● 背景変更補正画像を更新
    #--------------------------------------------------------------------------
    def update_back_adjust
    @active_data[9][0][0] = 0 if @scroll_x == 0
    @active_data[9][0][1] = 0 if @scroll_y == 0
    @active_data[9][1][0] -= @active_data[9][2][0] if @scroll_x == 0
    @active_data[9][1][1] -= @active_data[9][2][1] if @scroll_y == 0
    for i in 0...@bt_back.size
    @bt_back[i].x = -self.ox + @active_data[9][i][0] * $sv_camera.zoom
    @bt_back[i].y = -self.oy + @active_data[9][i][1] * $sv_camera.zoom
    @bt_back[i].zoom_x = self.zoom_x
    @bt_back[i].zoom_y = self.zoom_y
    @bt_back[i].z = self.z + 1
    @bt_back[i].color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
    end
    back_data_scroll_on if @active_data[9][0][0] == 0 && @active_data[9][0][1] == 0
    return unless @active_data[9][1][0] == 0 && @active_data[9][1][1] == 0
    bt_back_dispose
    create_back(@active_data[5])
    @active_data[9][0] = false
    next_back_data if @remain && @back_data.size != 1
    @remain = false
    end
    #--------------------------------------------------------------------------
    # ● 色調変更
    #--------------------------------------------------------------------------
    def color_set
    set = $sv_camera.color_set[@index]
    $sv_camera.color_set[@index] = nil
    set[4] = 1 if set[4] == 0
    @remain_color_data = [0,0,0,0] if @remain_color_data == nil
    @color_data = @remain_color_data
    @color_data[4] = set[4]
    @color_data[5] = set[5]
    @color_data[6] = set
    end
    #--------------------------------------------------------------------------
    # ● 背景変更補正画像の解放
    #--------------------------------------------------------------------------
    def bt_back_dispose
    for i in 0...@bt_back.size do @bt_back[i].dispose end if @bt_back != nil
    @bt_back = nil
    end
    #--------------------------------------------------------------------------
    # ● 解放
    #--------------------------------------------------------------------------
    def dispose
    bitmap.dispose if bitmap
    bt_back_dispose
    super
    end
    end

    #================================================= =============================
    # ■ Battle_Camera
    #------------------------------------------------------------------------------
    #  戦闘カメラやバトルプログラムを うクラスです。
    #================================================= =============================
    class Battle_Camera
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数 
    #--------------------------------------------------------------------------
    attr_reader :sx # シェイクX座標
    attr_reader :sy # シェイクY座標
    attr_reader :max_top # 上限界座標
    attr_reader :max_bottom # 下限界座標
    attr_reader :max_left # 左限界座標
    attr_reader :max_right # 右限界座標
    attr_accessor :switches # サイドビュー専用スイッチ
    attr_accessor :color_set # 色調変更データ
    attr_accessor :wait # 戦闘シーンの強制ウエイト
    attr_accessor :win_wait # 戦闘勝利前のウエイト
    attr_accessor :mirror # 画面反転フラグ
    attr_accessor rogram_scroll # バトルプログラム 背景の自動スクロール
    attr_accessor rogram_picture # バトルプログラム 周期ピクチャ
    attr_accessor :event # コモンイベント呼び出し
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    def initialize
    @switches = []
    @max_data = []
    @color_set = []
    @wait = 0
    @win_wait = false
    @mirror = false
    @event = false
    setup
    end
    #--------------------------------------------------------------------------
    # ● カメラX座標
    #--------------------------------------------------------------------------
    def x
    return @x / 100
    end
    #--------------------------------------------------------------------------
    # ● カメラY座標
    #--------------------------------------------------------------------------
    def y
    return @y / 100
    end
    #--------------------------------------------------------------------------
    # ● ズーム率
    #--------------------------------------------------------------------------
    def zoom
    return @zoom * 0.001
    end
    #--------------------------------------------------------------------------
    # ● ズーム率による座標変換
    #--------------------------------------------------------------------------
    def convert
    return @zoom
    end
    #--------------------------------------------------------------------------
    # ● カメラセットアップ
    #--------------------------------------------------------------------------
    def setup
    @x = 0
    @y = 0
    @sx = 0
    @sy = 0
    @zoom = 1000
    @time = 0
    @shake_time = 0
    program_setup
    end
    #--------------------------------------------------------------------------
    # ● カメラ初期化
    #--------------------------------------------------------------------------
    def reset
    @switches = []
    @max_data = []
    @color_set = []
    @wait = 0
    @win_wait = false
    @mirror = false
    program_setup(false)
    end
    #--------------------------------------------------------------------------
    # ● バトルプログラムのセットアップ
    #--------------------------------------------------------------------------
    def program_setup(check = true)
    @played_program = []
    @program_switch = []
    @program_sound = []
    @program_scroll = []
    @program_se = []
    @program_shake = []
    @program_color = []
    @program_picture = []
    @program_base = N03::BATTLE_PROGRAM.values.dup
    program_check if check
    end
    #--------------------------------------------------------------------------
    # ● バトルプログラムのチェック
    #--------------------------------------------------------------------------
    def program_check
    for data in @program_base
    if program_start?(data) && !@played_program.include?(data)
    @played_program.push(data.dup)
    @program_scroll.push(data.dup) if data[0] == "scroll"
    @program_picture.push(data.dup) if data[0] == "kpic"
    start_sound(data.dup) if data[0] == "sound"
    start_program_switch(data.dup) if data[0] == "switch"
    start_program_se(data.dup) if data[0] == "keep_se"
    start_program_shake(data.dup) if data[0] == "keep_sk"
    start_program_color(data.dup) if data[0] == "keep_c"
    else
    @played_program.delete(data) if !program_start?(data)
    @program_scroll.delete(data) if data[0] == "scroll"
    @program_picture.delete(data) if data[0] == "kpic"
    @program_switch.delete(data) if data[0] == "switch"
    @program_sound.delete(data) if data[0] == "sound"
    @program_se.delete(data) if data[0] == "keep_se"
    @program_shake.delete(data) if data[0] == "keep_sk"
    @program_color.delete(data) if data[0] == "keep_c"
    end
    end
    end
    #--------------------------------------------------------------------------
    # ● バトルプログラムの開始
    #--------------------------------------------------------------------------
    def program_start?(data)
    start = false
    start = true if $game_switches[data[1].abs] && data[1] > 0
    start = true if @switches[data[1].abs] && data[1] < 0
    return start
    end
    #--------------------------------------------------------------------------
    # ● バトルプログラム スイッチ操作の開始
    #--------------------------------------------------------------------------
    def start_program_switch(data)
    data[4] = data[4] + rand(data[5] + 1)
    data[4] = 1 if data[4] <= 0
    @program_switch.push(data)
    end
    #--------------------------------------------------------------------------
    # ● スイッチ操作の更新
    #--------------------------------------------------------------------------
    def update_program_switch
    for data in @program_switch
    data[4] -= 1
    next @program_switch.delete(data) if data[1] > 0 && !$game_switches[data[1]]
    next @program_switch.delete(data) if data[1] < 0 && !@switches[data[1].abs]
    next if data[4] != 0
    for id in data[2]
    $game_switches[id] = true if id > 0
    @switches[id.abs] = true if id < 0
    end
    for id in data[3]
    $game_switches[id] = false if id > 0
    @switches[id.abs] = false if id < 0
    end
    @program_switch.delete(data)
    program_check
    end
    end
    #--------------------------------------------------------------------------
    # ● バトルプログラム BGM/BGSの開始
    #--------------------------------------------------------------------------
    def start_sound(data)
    @program_sound.push(data)
    name = data[5]
    case data[2]
    when "se"
    Audio.se_play("Audio/SE/" + name, data[4], data[3])
    when "bgm"
    name = RPG::BGM.last.name if data[5] == ""
    Audio.bgm_play("Audio/BGM/" + name, data[4], data[3])
    when "bgs"
    name = RPG::BGS.last.name if data[5] == ""
    Audio.bgs_play("Audio/BGS/" + name, data[4], data[3])
    end
    end
    #--------------------------------------------------------------------------
    # ● バトルプログラム 周期SEの開始
    #--------------------------------------------------------------------------
    def start_program_se(data)
    data[3] = [data[2], data[3]]
    data[2] = data[3][0] + rand(data[3][1] + 1)
    @program_se.push(data)
    Audio.se_play("Audio/SE/" + data[7], data[5], data[4]) if data[6]
    end
    #--------------------------------------------------------------------------
    # ● 周期SEの更新
    #--------------------------------------------------------------------------
    def update_program_se
    for data in @program_se
    data[2] -= 1
    next @program_se.delete(data) if data[1] > 0 && !$game_switches[data[1]]
    next @program_se.delete(data) if data[1] < 0 && !@switches[data[1].abs]
    next if data[2] != 0
    Audio.se_play("Audio/SE/" + data[7], data[5], data[4])
    data[2] = data[3][0] + rand(data[3][1] + 1)
    end
    end
    #--------------------------------------------------------------------------
    # ● バトルプログラム 周期シェイクの開始
    #--------------------------------------------------------------------------
    def start_program_shake(data)
    data[3] = [data[2], data[3]]
    data[2] = data[3][0] + rand(data[3][1] + 1)
    @program_shake.push(data)
    shake(data[4], data[5], data[6]) if data[7]
    end
    #--------------------------------------------------------------------------
    # ● 周期シェイクの更新
    #--------------------------------------------------------------------------
    def update_program_shake
    for data in @program_shake
    data[2] -= 1
    next @program_shake.delete(data) if data[1] > 0 && !$game_switches[data[1]]
    next @program_shake.delete(data) if data[1] < 0 && !@switches[data[1].abs]
    next if data[2] != 0
    shake(data[4], data[5], data[6])
    data[2] = data[3][0] + rand(data[3][1] + 1)
    end
    end
    #--------------------------------------------------------------------------
    # ● バトルプログラム 周期色調変更の開始
    #--------------------------------------------------------------------------
    def start_program_color(data)
    data[3] = [data[2], data[3]]
    data[2] = data[3][0] + rand(data[3][1] + 1)
    data[7] = true if data[4] == 0 or data[4] == 4
    case data[4]
    when 1 ;data[4] = $game_troop.members
    when 2 ;data[4] = $game_party.battle_members
    when 3,4 ;data[4] = $game_troop.members + $game_party.battle_members
    else ;data[4] = []
    end
    @program_color.push(data)
    return if !data[6]
    for target in data[4] do target.sv.color_set = data[5] end if data[4] != []
    @color_set[1] = data[5] if data[7]
    @color_set[2] = data[5] if data[7]
    end
    #--------------------------------------------------------------------------
    # ● 周期色調変更の更新
    #--------------------------------------------------------------------------
    def update_program_color
    for data in @program_color
    data[2] -= 1
    next @program_color.delete(data) if data[1] > 0 && !$game_switches[data[1]]
    next @program_color.delete(data) if data[1] < 0 && !@switches[data[1].abs]
    next if data[2] != 0
    for target in data[4] do target.sv.color_set = data[5] end if data[4] != []
    @color_set[1] = data[5] if data[7]
    @color_set[2] = data[5] if data[7]
    data[2] = data[3][0] + rand(data[3][1] + 1)
    end
    end
    #--------------------------------------------------------------------------
    # ● トランジション実行
    #--------------------------------------------------------------------------
    def perform_transition(data)
    Graphics.transition(data[2], "Graphics/Pictures/" + data[3], data[1])
    end
    #--------------------------------------------------------------------------
    # ● 背景からカメラの限界値を取得 data = [max_top, max_bottom, max_left, max_right]
    #--------------------------------------------------------------------------
    def setting(index, data)
    @max_data[index - 1] = data
    return if index != 2
    setup
    # カメラの中心座標
    @center_x = (Graphics.width / 2 + N03::CAMERA_POSITION[0]) * 100
    @center_y = (Graphics.height / 2 + N03::CAMERA_POSITION[1]) * 100
    # 上下左右の移動限界距離
    @max_top = [@max_data[0][5], @max_data[1][5]].min * -1
    @max_bottom = [@max_data[0][1], @max_data[1][1]].min + @max_top
    @max_left = [@max_data[0][4], @max_data[1][4]].min * -1
    @max_right = [@max_data[0][3], @max_data[1][3]].min + @max_left
    exist_data = @max_data[0] if !@max_data[1][6]
    exist_data = @max_data[1] if !@max_data[0][6]
    @max_top = exist_data[5] * -1 if exist_data != nil
    @max_bottom = exist_data[1] + @max_top if exist_data != nil
    @max_left = exist_data[4] * -1 if exist_data != nil
    @max_right = exist_data[3] + @max_left if exist_data != nil
    @max_top = @max_bottom = @max_left = @max_right = 0 if !@max_data[1][6] && !@max_data[0][6]
    @max_width = @max_right - @max_left + Graphics.width
    @max_height = @max_bottom - @max_top + Graphics.height
    # ズームアウト限界値
    max_zoom_x = 100 * Graphics.width / @max_width
    max_zoom_y = 100 * Graphics.height / @max_height
    @max_zoom_out = [max_zoom_x, max_zoom_y].max
    end
    #--------------------------------------------------------------------------
    # ● カメラ移動
    #--------------------------------------------------------------------------
    def move(target_x, target_y, zoom, time, screen = true)
    # 戦闘背景以上のサイズまでズームア トしないよう調整
    @target_zoom = [zoom * 0.01, @max_zoom_out * 0.01].max
    target_x *= -1 if screen && @mirror
    # ズーム分の中心座標補正
    if screen && @target_zoom != 1
    target_x = target_x + @center_x
    target_y = target_y + @center_y
    end
    adjust_x = @center_x * (@target_zoom - 1) / (@target_zoom ** 2 - @target_zoom)
    adjust_y = @center_y * (@target_zoom - 1) / (@target_zoom ** 2 - @target_zoom)
    adjust_x = 0 if adjust_x.nan?
    adjust_y = 0 if adjust_y.nan?
    adjust_x = @center_x if !screen && adjust_x == 0
    adjust_y = @center_y if !screen && adjust_y == 0
    @target_x = target_x - adjust_x.to_i
    @target_y = target_y - adjust_y.to_i
    @target_zoom = (@target_zoom * 1000).to_i
    @zoom = @zoom.to_i
    limit_test
    # 時間0の場合は即実行
    return @time = time.abs if time != 0
    @time = 1
    update
    end
    #--------------------------------------------------------------------------
    # ● 限界座標の試算
    #--------------------------------------------------------------------------
    def limit_test
    new_width = @max_width * @target_zoom / 1000
    new_height = @max_height * @target_zoom / 1000
    new_max_right = @max_right - (@max_width - new_width)
    new_max_bottom = @max_bottom - (@max_height - new_height)
    # 画面の移動先が限界の場合、限界座 をセット
    if @target_x < @max_left * 100
    @target_x = @max_left * 100
    end
    if @target_x > new_max_right * 100
    @target_x = new_max_right * 100
    end
    if @target_y < @max_top * 100
    @target_y = @max_top * 100
    end
    if @target_y > new_max_bottom * 100
    @target_y = new_max_bottom * 100
    end
    end
    #--------------------------------------------------------------------------
    # ● 画面のシェイク
    #--------------------------------------------------------------------------
    def shake(power, speed, time)
    @shake_x = power[0] * 100
    @shake_y = power[1] * 100
    @power_time_base = @power_time = speed
    @shake_time = time
    update_shake
    end
    #--------------------------------------------------------------------------
    # ● シェイクの更新
    #--------------------------------------------------------------------------
    def update_shake
    @sx = (@sx * (@power_time - 1) + @shake_x) / @power_time
    @sy = (@sy * (@power_time - 1) + @shake_y) / @power_time
    @power_time -= 1
    @shake_time -= 1
    return @sx = @sy = 0 if @shake_time == 0
    return if @power_time != 0
    @power_time = @power_time_base
    @shake_x = @shake_x * -4 / 5
    @shake_y = @shake_y * -4 / 5
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def update
    update_shake if @shake_time != 0
    update_program
    return if @time == 0
    @x = (@x * (@time - 1) + @target_x) / @time
    @y = (@y * (@time - 1) + @target_y) / @time
    @zoom = (@zoom * (@time - 1) + @target_zoom) / @time
    @time -= 1
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    def update_program
    update_program_switch if @program_switch != []
    update_program_se if @program_se != []
    update_program_shake if @program_shake != []
    update_program_color if @program_color != []
    end
    end

    #================================================= =============================
    # ■ Scene_Battle
    #------------------------------------------------------------------------------
    #  バトル画面の処理を行うクラスで 。
    #================================================= =============================
    class Scene_Battle < Scene_Base
    #--------------------------------------------------------------------------
    # ● フレーム更新(基本)
    #--------------------------------------------------------------------------
    alias update_basic_scene_battle_n03 update_basic
    def update_basic
    update_basic_scene_battle_n03
    $sv_camera.update
    $sv_camera.wait = N03::TURN_END_WAIT + 1 if $sv_camera.win_wait
    camera_wait
    end
    #--------------------------------------------------------------------------
    # ● カメラウェイト
    #--------------------------------------------------------------------------
    def camera_wait
    process_event if $sv_camera.event
    $sv_camera.event = false if $sv_camera.event
    while $sv_camera.wait != 0
    Graphics.update
    Input.update
    update_all_windows
    $game_timer.update
    $game_troop.update
    $sv_camera.update
    @spriteset.update
    update_info_viewport
    update_message_open
    $sv_camera.wait -= 1 if $sv_camera.wait > 0
    $sv_camera.wait = 1 if $sv_camera.wait == 0 && @spriteset.effect?
    BattleManager.victory if $sv_camera.win_wait && $sv_camera.wait == 0
    end
    end
    #--------------------------------------------------------------------------
    # ● カメラウェイトのセット
    #--------------------------------------------------------------------------
    def set_camera_wait(time)
    $sv_camera.wait = time
    camera_wait
    end
    #--------------------------------------------------------------------------
    # ● エフェクト実行が終わるまでウェイ ★再定義
    #--------------------------------------------------------------------------
    def wait_for_effect
    end
    #--------------------------------------------------------------------------
    # ● ターン開始
    #--------------------------------------------------------------------------
    alias turn_start_scene_battle_n03 turn_start
    def turn_start
    turn_start_scene_battle_n03
    N03.camera(nil, N03::BATTLE_CAMERA["ターン開始後"].dup)
    end
    #--------------------------------------------------------------------------
    # ● ターン終了
    #--------------------------------------------------------------------------
    alias turn_end_scene_battle_n03 turn_end
    def turn_end
    turn_end_scene_battle_n03
    for member in $game_troop.members + $game_party.members
    N03.set_damage(member, member.sv.result_damage[0],member.sv.result_damage[1])
    member.sv.result_damage = [0,0]
    @spriteset.set_damage_pop(member) if member.result.hp_damage != 0 or member.result.mp_damage != 0
    end
    set_camera_wait(N03::TURN_END_WAIT)
    N03.camera(nil, N03::BATTLE_CAMERA["ターン開始前"].dup) if $game_party.inputable?
    @log_window.clear
    end
    #--------------------------------------------------------------------------
    # ● スキル/アイテムの使用 ★再定義
    #--------------------------------------------------------------------------
    def use_item
    item = @subject.current_action.item
    display_item(item)
    @subject.use_item(item)
    refresh_status
    @targets = @subject.current_action.make_targets.compact
    @targets = [@subject] if @targets.size == 0
    set_substitute(item)
    for time in item.repeats.times do play_sideview(@targets, item) end
    end_reaction(item)
    display_end_item
    end
    #--------------------------------------------------------------------------
    # ● スキル/アイテム名の表示
    #--------------------------------------------------------------------------
    def display_item(item)
    return @log_window.display_use_item(@subject, item) if N03::BATTLE_LOG
    @log_window.off
    @skill_name_window = Window_Skill_name.new(item.name) unless N03::NO_DISPLAY_SKILL_ID.include?(item.id) && item.is_a?(RPG::Skill)
    end
    #--------------------------------------------------------------------------
    # ● スキル/アイテム名の表示終了
    #--------------------------------------------------------------------------
    def display_end_item
    @skill_name_window.dispose if @skill_name_window != nil
    @skill_name_window = nil
    set_camera_wait(N03::ACTION_END_WAIT) if @subject.sv.derivation_skill_id == 0
    @log_window.clear if N03::BATTLE_LOG
    end
    #--------------------------------------------------------------------------
    # ● 反撃/魔法反射/身代わり処理
    #--------------------------------------------------------------------------
    def end_reaction(item)
    end_substitute if @substitute != nil
    set_reflection(item) if @reflection_data != nil
    set_counter_attack if @counter_attacker != nil
    end
    #--------------------------------------------------------------------------
    # ● 反撃の発動 ★再定義
    #--------------------------------------------------------------------------
    def invoke_counter_attack(target, item)
    return if @subject.sv.counter_id != 0
    @counter_attacker = [] if @counter_attacker == nil
    return apply_item_effects(apply_substitute(target, item), item) if !target.movable?
    @log_window.add_text(sprintf(Vocab::CounterAttack, target.name)) if N03::BATTLE_LOG
    target.sv.counter_id = target.sv.counter_skill_id
    @counter_attacker.push(target)
    end
    #--------------------------------------------------------------------------
    # ● 魔法反射の発動 ★再定義
    #--------------------------------------------------------------------------
    def invoke_magic_reflection(target, item)
    return if @subject.sv.reflection_id != 0
    @log_window.add_text(sprintf(Vocab::MagicReflectio n, target.name)) if N03::BATTLE_LOG
    target.sv.reflection_id = target.sv.reflection_anime_id
    end
    #--------------------------------------------------------------------------
    # ● 身代わりの適用 ★再定義
    #--------------------------------------------------------------------------
    def apply_substitute(target, item)
    return target if @substitute == nil
    return target if !check_substitute(target, item)
    return @substitute
    end
    #--------------------------------------------------------------------------
    # ● 身代わりセット
    #--------------------------------------------------------------------------
    def set_substitute(item)
    @substitute = N03.get_enemy_unit(@subject).substitute_battler
    return if @substitute == nil
    s_targets = []
    for i in 0...@targets.size
    next if @targets[i] == @substitute
    next if !check_substitute(@targets[i], item)
    @log_window.add_text(sprintf(Vocab::Substitute, @substitute.name, @targets[i].name))
    @targets[i].sv.start_action(@targets[i].sv.substitute_receiver_start_action)
    s_targets.push(@targets[i])
    @targets[i] = @substitute
    end
    return @substitute = nil if s_targets == []
    @substitute.sv.set_target(s_targets)
    @substitute.sv.start_action(@substitute.sv.substit ute_start_action)
    end
    #--------------------------------------------------------------------------
    # ● 身代わり終了
    #--------------------------------------------------------------------------
    def end_substitute
    for member in @substitute.sv.target_battler
    member.sv.start_action(member.sv.substitute_receiv er_end_action)
    end
    @substitute.sv.start_action(@substitute.sv.substit ute_end_action)
    @substitute = nil
    end
    #--------------------------------------------------------------------------
    # ● 反撃
    #--------------------------------------------------------------------------
    def set_counter_attack
    pre_subject = @subject
    for attacker in @counter_attacker
    @subject = attacker
    item = $data_skills[attacker.sv.counter_skill_id]
    play_sideview([pre_subject], item)
    end
    # 同一カウンター者を考慮してカウン ーIDの初期化はアクション後に実行
    for attacker in @counter_attacker do attacker.sv.counter_id = 0 end
    @subject = pre_subject
    @counter_attacker = nil
    end
    #--------------------------------------------------------------------------
    # ● 魔法反射
    #--------------------------------------------------------------------------
    def set_reflection(item)
    @log_window.back_to(1)
    for data in @reflection_data
    @subject.sv.damage_action(@subject, item)
    N03.set_damage_anime_data([@subject], @subject, data)
    apply_item_effects(@subject, item)
    @spriteset.set_damage_pop(@subject)
    end
    set_camera_wait(N03.get_anime_time(@reflection_dat a[0][0]))
    @reflection_data = nil
    end
    #--------------------------------------------------------------------------
    # ● サイドビューアクション実行
    #--------------------------------------------------------------------------
    def play_sideview(targets, item)
    @subject.sv.set_target(targets)
    return if @subject.sv.attack_action(item) == nil
    return if !@subject.movable?
    return if item.scope != 9 && item.scope != 10 && !N03.targets_alive?(targets)
    @subject.sv.start_action(@subject.sv.attack_action (item))
    @subject.sv.unshift_action(@subject.sv.flash_actio n) if @subject.flash_flg
    @subject.sv.active = true
    @subject.sv.command_action = false
    loop do
    update_basic
    data = @subject.sv.play_data
    @targets = N03.s_targets(@subject) if data[0] == "second_targets_set"
    N03.targets_set(@subject) if data[0] == "targets_set"
    @immortal = N03.immortaling if data[0] == "no_collapse" && !N03.dead_attack?(@subject, item)
    @immortal = N03.unimmortaling if data[0] == "collapse"
    next set_move_anime(item) if @subject.sv.m_a_data != []
    set_damage(item) if @subject.sv.set_damage
    break N03.derived_skill(@subject) if @subject.sv.derivation_skill_id != 0
    break if @subject.sv.action_end or @subject.hidden?
    end
    @immortal = N03.unimmortaling if @immortal
    end
    #--------------------------------------------------------------------------
    # ● ダメージの実行
    #--------------------------------------------------------------------------
    def set_damage(item)
    targets = @targets
    targets = [@subject.sv.individual_targets[0]] if @subject.sv.individual_targets.size != 0
    for target in targets do damage_anime(targets.dup, target, item) end
    @subject.sv.set_damage = false
    @subject.sv.damage_anime_data = []
    end
    #--------------------------------------------------------------------------
    # ● ダメージ戦闘アニメ処理
    #--------------------------------------------------------------------------
    def damage_anime(targets, target, item)
    @log_window.back_to(1) if @log_window.line_number == 5
    return if item.scope != 9 && item.scope != 10 && target.dead?
    @miss = false
    invoke_item(target,item)
    if target.result.missed
    target.sv.miss_action(@subject, item)
    return @miss = true
    elsif target.result.evaded or target.sv.counter_id != 0
    target.sv.evasion_action(@subject, item)
    return @miss = true
    elsif target.sv.reflection_id != 0
    N03.set_damage_anime_data(targets, target, [target.sv.reflection_id, false, false, true])
    target.sv.reflection_id = 0
    @reflection_data = [] if @reflection_data == nil
    return @reflection_data.push([N03.get_attack_anime_id(-3, @subject), false, false, true])
    end
    target.sv.damage_action(@subject, item)
    N03.set_damage(@subject, -target.result.hp_drain, -target.result.mp_drain) if target != @subject
    @spriteset.set_damage_pop(target)
    @spriteset.set_damage_pop(@subject) if target != @subject && @subject.result.hp_damage != 0 or @subject.result.mp_damage != 0
    N03.set_damage_anime_data(targets, target, @subject.sv.damage_anime_data) if @subject.sv.damage_anime_data != []
    end
    #--------------------------------------------------------------------------
    # ● 飛ばしアニメ処理
    #--------------------------------------------------------------------------
    def set_move_anime(item)
    for data in @subject.sv.m_a_data
    @subject.sv.damage_anime_data = data[4]
    hit_targets = []
    for target in data[1]
    damage_anime(data[1], target, item) if data[0]
    hit_targets.push(target) if !@miss
    end
    @miss = false if !data[3]
    @spriteset.set_hit_animation(@subject, data[2], hit_targets, @miss)
    end
    @subject.sv.set_damage = false
    @subject.sv.m_a_data = []
    end
    end

    #================================================= =============================
    # ■ DataManager
    #------------------------------------------------------------------------------
    #  データベースとゲームオブジェク を管理するモジュールです。
    #================================================= =============================
    module DataManager
    #--------------------------------------------------------------------------
    # ● 各種ゲームオブジェクトの作成 ★再定義
    #--------------------------------------------------------------------------
    def self.create_game_objects
    $game_temp = Game_Temp.new
    $game_system = Game_System.new
    $game_timer = Game_Timer.new
    $game_message = Game_Message.new
    $game_switches = Game_Switches.new
    $game_variables = Game_Variables.new
    $game_self_switches = Game_SelfSwitches.new
    $game_actors = Game_Actors.new
    $game_party = Game_Party.new
    $game_troop = Game_Troop.new
    $game_map = Game_Map.new
    $game_player = Game_Player.new
    $sv_camera = Battle_Camera.new
    end
    end

    #================================================= =============================
    # ■ BattleManager
    #------------------------------------------------------------------------------
    #  戦闘の進行を管理するモジュール す。
    #================================================= =============================
    module BattleManager
    #--------------------------------------------------------------------------
    # ● エンカウント時の処理 ★再定義
    #--------------------------------------------------------------------------
    def self.on_encounter
    @preemptive = (rand < rate_preemptive)
    @surprise = (rand < rate_surprise && !@preemptive)
    $sv_camera.mirror = @surprise if N03::BACK_ATTACK
    end
    #--------------------------------------------------------------------------
    # ● 勝利の処理 ★再定義
    #--------------------------------------------------------------------------
    def self.process_victory
    $sv_camera.win_wait = true
    end
    #--------------------------------------------------------------------------
    # ● 勝利
    #--------------------------------------------------------------------------
    def self.victory
    $sv_camera.win_wait = false
    N03.camera(nil, N03::BATTLE_CAMERA["戦闘終了時"].dup)
    for member in $game_party.members do member.sv.start_action(member.sv.win) if member.movable? end
    play_battle_end_me
    replay_bgm_and_bgs
    $game_message.add(sprintf(Vocab::Victory, $game_party.name))
    display_exp
    gain_gold
    gain_drop_items
    gain_exp
    SceneManager.return
    battle_end(0)
    return true
    end
    #--------------------------------------------------------------------------
    # ● 逃走の処理 ★再定義
    #--------------------------------------------------------------------------
    def self.process_escape
    $game_message.add(sprintf(Vocab::EscapeStart, $game_party.name))
    success = @preemptive ? true : (rand < @escape_ratio)
    Sound.play_escape
    if success
    process_abort
    for member in $game_party.members do member.sv.start_action(member.sv.escape) if member.movable? end
    else
    @escape_ratio += 0.1
    $game_message.add('\.' + Vocab::EscapeFailure)
    $game_party.clear_actions
    for member in $game_party.members do member.sv.start_action(member.sv.escape_ng) if member.movable? end
    end
    wait_for_message
    return success
    end
    #--------------------------------------------------------------------------
    # ● 次のコマンド入力へ ★再定義
    #--------------------------------------------------------------------------
    def self.next_command
    begin
    if !actor || !actor.next_command
    $game_party.battle_members[@actor_index].sv.command_action = true
    @actor_index += 1
    if @actor_index >= $game_party.members.size
    for member in $game_party.battle_members.reverse
    break member.sv.start_action(member.sv.command_a) if member.inputable?
    end
    return false
    end
    end
    end until actor.inputable?
    actor.sv.start_action(actor.sv.command_b) if actor != nil && actor.inputable?
    if pre_actor
    pre_actor.sv.start_action(pre_actor.sv.command_a) if pre_actor != nil && pre_actor.inputable?
    end
    return true
    end
    #--------------------------------------------------------------------------
    # ● 前のコマンド入力へ ★再定義
    #--------------------------------------------------------------------------
    def self.prior_command
    begin
    if !actor || !actor.prior_command
    $game_party.battle_members[@actor_index].sv.command_action = false
    @actor_index -= 1
    if @actor_index < 0
    for member in $game_party.battle_members
    break member.sv.start_action(member.sv.command_a) if member.inputable?
    end
    return false
    end
    end
    end until actor.inputable?
    actor.make_actions if actor.inputable?
    actor.sv.start_action(actor.sv.command_b) if actor.inputable?
    after_actor.sv.start_action(after_actor.sv.command _a) if after_actor != nil && after_actor.inputable?
    return true
    end
    #--------------------------------------------------------------------------
    # ● コマンド入力前のアクターを取得
    #--------------------------------------------------------------------------
    def self.pre_actor
    return if @actor_index == 0
    $game_party.members[@actor_index - 1]
    end
    #--------------------------------------------------------------------------
    # ● コマンド入力後のアクターを取得
    #--------------------------------------------------------------------------
    def self.after_actor
    $game_party.members[@actor_index + 1]
    end
    #--------------------------------------------------------------------------
    # ● 戦闘行動者を前に追加
    #--------------------------------------------------------------------------
    def self.unshift_action_battlers(battler)
    @action_battlers.unshift(battler)
    end
    end

    #================================================= =============================
    # ■ Game_Battler
    #------------------------------------------------------------------------------
    #  スプライトや行動に関するメソッ を追加したバトラーのクラスです。
    #================================================= =============================
    class Game_Battler < Game_BattlerBase
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数
    #--------------------------------------------------------------------------
    attr_reader :sv # サイドビューデータ
    attr_accessor :flash_flg # 閃きフラグ
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    alias initialize_game_battler_n03 initialize
    def initialize
    initialize_game_battler_n03
    @sv = SideView.new(self)
    end
    #--------------------------------------------------------------------------
    # ● 現在の戦闘行動を除去
    #--------------------------------------------------------------------------
    alias remove_current_action_game_battler_n03 remove_current_action
    def remove_current_action
    return @sv.derivation_skill_id = 0 if @sv.derivation_skill_id != 0
    remove_current_action_game_battler_n03
    end
    #--------------------------------------------------------------------------
    # ● ターン終了処理
    #--------------------------------------------------------------------------
    alias on_turn_end_game_battler_n03 on_turn_end
    def on_turn_end
    on_turn_end_game_battler_n03
    @sv.add_state = []
    @sv.result_damage = [@result.hp_damage, @result.mp_damage]
    end
    #--------------------------------------------------------------------------
    # ● パラメータ条件比較 data = [種別, 数値, 判別]
    #--------------------------------------------------------------------------
    def comparison_parameter(data)
    return true if data[0][0] == 0
    kind = data[0]
    num = data[1]
    select = data[2]
    case kind
    when 1 ; par = level
    when 2 ; par = mhp
    when 3 ; par = mmp
    when 4 ; par = hp
    when 5 ; par = mp
    when 6 ; par = tp
    when 7 ; par = atk
    when 8 ; par = self.def
    when 9 ; par = mat
    when 10 ; par = mdf
    when 11 ; par = agi
    when 12 ; par = luk
    end
    if num < 0
    case kind
    when 4 ; num = mhp * num / 100
    when 5 ; num = mmp * num / 100
    when 6 ; num = max_tp * num / 100
    end
    num = num.abs
    end
    case select
    when 0 ; return par == num
    when 1 ; return par < num
    when 2 ; return par > num
    end
    end
    #--------------------------------------------------------------------------
    # ● 装備条件比較 data = [装備種別, タイプID]
    #--------------------------------------------------------------------------
    def comparison_equip(data)
    kind = data[0]
    items = weapons if kind == 0
    items = armors if kind == 1
    for item in items
    for id in data[1]
    return true if id > 0 && item.is_a?(RPG::Weapon) && item == $data_weapons[id.abs]
    return true if id > 0 && item.is_a?(RPG::Armor) && item == $data_armors[id.abs]
    return true if id < 0 && item.is_a?(RPG::Weapon) && item.wtype_id == id.abs
    return true if id < 0 && item.is_a?(RPG::Armor) && item.stype_id == id.abs
    end
    end
    return false
    end

    end
    #================================================= =============================
    # ■ Game_Actor
    #------------------------------------------------------------------------------
    #  アクターを扱うクラスです。
    #================================================= =============================
    class Game_Actor < Game_Battler
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数
    #--------------------------------------------------------------------------
    attr_reader :actor_id # ID
    #--------------------------------------------------------------------------
    # ● ID
    #--------------------------------------------------------------------------
    def id
    return @actor_id
    end
    #--------------------------------------------------------------------------
    # ● スプライトを使うか? ★再定義
    #--------------------------------------------------------------------------
    def use_sprite?
    return true
    end
    #--------------------------------------------------------------------------
    # ● ダメージ効果の実行 ★再定義
    #--------------------------------------------------------------------------
    def perform_damage_effect
    return if !N03::ACTOR_DAMAGE
    $game_troop.screen.start_shake(5, 5, 10)
    @sprite_effect_type = :blink
    Sound.play_actor_damage
    end

    end

    #================================================= =============================
    # ■ Game_Enemy
    #------------------------------------------------------------------------------
    #  敵キャラを扱うクラスです。
    #================================================= =============================
    class Game_Enemy < Game_Battler
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数
    #--------------------------------------------------------------------------
    attr_reader :enemy_id # ID
    #--------------------------------------------------------------------------
    # ● ID
    #--------------------------------------------------------------------------
    def id
    return @enemy_id
    end
    #--------------------------------------------------------------------------
    # ● レベル
    #--------------------------------------------------------------------------
    def level
    return @sv.level
    end
    #--------------------------------------------------------------------------
    # ● ダメージ効果の実行 ★再定義
    #--------------------------------------------------------------------------
    def perform_damage_effect
    return if !N03::ENEMY_DAMAGE
    @sprite_effect_type = :blink
    Sound.play_enemy_damage
    end
    #--------------------------------------------------------------------------
    # ● 武器
    #--------------------------------------------------------------------------
    def weapons
    weapon1 = $data_weapons[@sv.enemy_weapon1_id]
    weapon2 = $data_weapons[@sv.enemy_weapon2_id]
    return [weapon1, weapon2]
    end
    #--------------------------------------------------------------------------
    # ● 防具
    #--------------------------------------------------------------------------
    def armors
    return [$data_armors[@sv.enemy_shield_id]]
    end
    #--------------------------------------------------------------------------
    # ● 二刀流の判定
    #--------------------------------------------------------------------------
    def dual_wield?
    return $data_weapons[@sv.enemy_weapon2_id] != nil
    end
    #--------------------------------------------------------------------------
    # ● バトラー画像変更
    #--------------------------------------------------------------------------
    def graphics_change(battler_name)
    @battler_name = battler_name
    end
    #--------------------------------------------------------------------------
    # ● 通常攻撃 アニメーション ID の取得
    #--------------------------------------------------------------------------
    def atk_animation_id1
    return weapons[0].animation_id if weapons[0]
    return weapons[1] ? 0 : 1
    end
    #--------------------------------------------------------------------------
    # ● 通常攻撃 アニメーション ID の取得(二刀流:武器2)
    #--------------------------------------------------------------------------
    def atk_animation_id2
    return weapons[1] ? weapons[1].animation_id : 0
    end
    end

    #================================================= =============================
    # ■ Sprite_Base
    #------------------------------------------------------------------------------
    #  アニメーションの表示処理を追加 たスプライトのクラスです。
    #================================================= =============================
    class Sprite_Base < Sprite
    #--------------------------------------------------------------------------
    # ● アニメーションの座標更新 (ホーミングあり)
    #--------------------------------------------------------------------------
    def update_animation_position_horming
    return if @action_end_cancel
    ani_ox_set if @horming
    camera_zoom = $sv_camera.zoom
    camera_zoom = 1 if @move_anime
    kind = 1
    kind = -1 if @ani_mirror && !@anime_no_mirror
    cell_data = @animation.frames[@animation.frame_max - (@ani_duration + @ani_rate - 1) / @ani_rate].cell_data
    for i in 0..15
    @ani_sprites[i].x = (@ani_ox + cell_data[i, 1] * kind - $sv_camera.x) * camera_zoom if @ani_sprites[i] != nil && cell_data[i, 1] != nil
    @ani_sprites[i].y = (@ani_oy + cell_data[i, 2] - $sv_camera.y) * camera_zoom if @ani_sprites[i] != nil && cell_data[i, 2] != nil
    end
    end
    #--------------------------------------------------------------------------
    # ● アニメーション元の座標をセット
    #--------------------------------------------------------------------------
    def ani_ox_set
    if !SceneManager.scene_is?(Scene_Battle)
    @real_x = x
    @real_y = y
    end
    @ani_ox = @real_x - ox + width / 2
    @ani_oy = @real_y - oy + height / 2
    @ani_oy -= height / 2 if @animation.position == 0
    @ani_oy += height / 2 if @animation.position == 2
    end
    #--------------------------------------------------------------------------
    # ● アニメーションの更新
    #--------------------------------------------------------------------------
    alias update_animation_sprite_base_n03 update_animation
    def update_animation
    update_animation_position_horming if animation? && SceneManager.scene_is?(Scene_Battle) && @animation.position != 3
    update_animation_sprite_base_n03
    end
    #--------------------------------------------------------------------------
    # ● アニメーションの原点設定 ★再定義
    #--------------------------------------------------------------------------
    def set_animation_origin
    return ani_ox_set if @animation.position != 3
    if viewport == nil
    @ani_ox = Graphics.width / 2
    @ani_oy = Graphics.height / 2
    else
    @ani_ox = viewport.rect.width / 2
    @ani_oy = viewport.rect.height / 2
    end
    end
    #--------------------------------------------------------------------------
    # ● アニメーションスプライトの設定 ★再定義
    #--------------------------------------------------------------------------
    def animation_set_sprites(frame)
    camera_zoom = 1
    camera_zoom = $sv_camera.zoom if @anime_camera_zoom && @animation.position != 3 && SceneManager.scene_is?(Scene_Battle)
    camera_x = $sv_camera.x
    camera_y = $sv_camera.y
    camera_x = camera_y = 0 if @animation.position == 3 or !SceneManager.scene_is?(Scene_Battle)
    plus_z = 5
    plus_z = 1000 if @animation.position == 3
    plus_z = -17 if @plus_z != nil && @plus_z == false
    plus_z = -self.z + 10 if @plus_z != nil && @plus_z == false && @animation.position == 3
    cell_data = frame.cell_data
    @ani_sprites.each_with_index do |sprite, i|
    next unless sprite
    pattern = cell_data[i, 0]
    if !pattern || pattern < 0
    sprite.visible = false
    next
    end
    sprite.bitmap = pattern < 100 ? @ani_bitmap1 : @ani_bitmap2
    sprite.visible = true
    sprite.src_rect.set(pattern % 5 * 192,
    pattern % 100 / 5 * 192, 192, 192)
    if @ani_mirror && !@anime_no_mirror
    sprite.x = (@ani_ox - cell_data[i, 1] - camera_x) * camera_zoom
    sprite.y = (@ani_oy + cell_data[i, 2] - camera_y) * camera_zoom
    sprite.angle = (360 - cell_data[i, 4])
    sprite.mirror = (cell_data[i, 5] == 0)
    else
    sprite.x = (@ani_ox + cell_data[i, 1] - camera_x) * camera_zoom
    sprite.y = (@ani_oy + cell_data[i, 2] - camera_y) * camera_zoom
    sprite.angle = cell_data[i, 4]
    sprite.mirror = (cell_data[i, 5] == 1)
    end
    sprite.z = self.z + plus_z + i
    sprite.ox = 96
    sprite.oy = 96
    sprite.zoom_x = cell_data[i, 3] * camera_zoom / 100.0
    sprite.zoom_y = cell_data[i, 3] * camera_zoom/ 100.0
    sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
    sprite.blend_type = cell_data[i, 7]
    end
    end
    #--------------------------------------------------------------------------
    # ● 子スプライトフラグ
    #--------------------------------------------------------------------------
    def set(battler, horming, camera_zoom, no_mirror)
    @battler = battler
    @next = true
    self.bitmap = Bitmap.new(@battler.sv.cw, @battler.sv.ch)
    self.ox = bitmap.width / 2
    self.oy = bitmap.height
    @horming = horming
    @anime_camera_zoom = camera_zoom
    @anime_no_mirror = no_mirror
    @battler.sv.reset_anime_data
    end
    #--------------------------------------------------------------------------
    # ● 子スプライト座標セット
    #--------------------------------------------------------------------------
    def set_position(z, zoom_x, zoom_y, real_x, real_y)
    self.z = z
    self.zoom_x = zoom_x
    self.zoom_y = zoom_y
    @real_x = real_x
    @real_y = real_y
    end
    #--------------------------------------------------------------------------
    # ● 他スプライトへのタイミング処理
    #--------------------------------------------------------------------------
    def other_process_timing(timing)
    se_flag = true
    se_flag = @se_flag if @se_flag != nil
    @battler.sv.timing.push([se_flag, timing.dup])
    end
    #--------------------------------------------------------------------------
    # ● 他バトラーへのタイミング処理
    #--------------------------------------------------------------------------
    def target_battler_process_timing(timing)
    for target in @timing_targets
    target.sv.timing.push([false, timing.dup])
    end
    end
    #--------------------------------------------------------------------------
    # ● SE とフラッシュのタイミング処理
    #--------------------------------------------------------------------------
    alias animation_process_timing_sprite_base_n03 animation_process_timing
    def animation_process_timing(timing)
    target_battler_process_timing(timing) if @timing_targets && @timing_targets != []
    return other_process_timing(timing) if @next != nil
    animation_process_timing_sprite_base_n03(timing)
    end
    #--------------------------------------------------------------------------
    # ● アニメーションの解放
    #--------------------------------------------------------------------------
    alias dispose_animation_sprite_base_n03 dispose_animation
    def dispose_animation
    dispose_animation_sprite_base_n03
    end
    end


    #================================================= =============================
    # ■ Sprite_Battler
    #------------------------------------------------------------------------------
    #  バトラー表示用のスプライトです
    #================================================= =============================
    class Sprite_Battler < Sprite_Base
    #--------------------------------------------------------------------------
    # ● 公開インスタンス変数 
    #--------------------------------------------------------------------------
    attr_accessor :removing # パーティ離脱中
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #--------------------------------------------------------------------------
    alias initialize_sprite_battler_n03 initialize
    def initialize(viewport, battler = nil)
    initialize_sprite_battler_n03(viewport, battler)
    @real_x = @real_y = 0
    update_bitmap if @battler != nil
    end
    #--------------------------------------------------------------------------
    # ● アニメーションの開始 ★再定義
    #--------------------------------------------------------------------------
    def start_animation(animation, mirror = false)
    return next_animation(animation, mirror) if animation?
    @animation = animation
    if @animation
    @horming = @battler.sv.anime_horming
    @anime_camera_zoom = @battler.sv.anime_camera_zoom
    @anime_no_mirror = @battler.sv.anime_no_mirror
    @timing_targets = @battler.sv.timing_targets
    @plus_z = @battler.sv.anime_plus_z
    @battler.sv.reset_anime_data
    @ani_mirror = mirror
    set_animation_rate
    @ani_duration = @animation.frame_max * @ani_rate + 1
    load_animation_bitmap
    make_animation_sprites
    set_animation_origin
    end
    end
    #--------------------------------------------------------------------------
    # ● 次のアニメを開始
    #--------------------------------------------------------------------------
    def next_animation(animation, mirror)
    @next_anime = [] if @next_anime == nil
    @next_anime.push(Sprite_Base.new(viewport))
    @next_anime[@next_anime.size - 1].set(battler, @battler.sv.anime_horming, @battler.sv.anime_camera_zoom, @battler.sv.anime_no_mirror)
    @next_anime[@next_anime.size - 1].set_position(self.z, self.zoom_x, self.zoom_y, @real_x, @real_y)
    @next_anime[@next_anime.size - 1].start_animation(animation, mirror)
    end
    #--------------------------------------------------------------------------
    # ● 影グラフィック作成
    #--------------------------------------------------------------------------
    def create_shadow
    reset_shadow
    return if @battler.sv.shadow == false
    @shadow = Sprite.new(viewport) if @shadow == nil
    @shadow.bitmap = Cache.character(@battler.sv.shadow)
    @shadow.ox = @shadow.bitmap.width / 2
    @shadow.oy = @shadow.bitmap.height / 2
    end
    #--------------------------------------------------------------------------
    # ● 影グラフィック初期化
    #--------------------------------------------------------------------------
    def reset_shadow
    return if @shadow == nil
    @shadow.dispose
    @shadow = nil
    end
    #--------------------------------------------------------------------------
    # ● 転送元ビットマップの更新 ★再定義
    #--------------------------------------------------------------------------
    def update_bitmap
    update_bitmap_enemy if !@battler.actor?
    update_bitmap_actor if @battler.actor?
    update_src_rect if @battler != nil
    update_color if @battler != nil
    end
    #--------------------------------------------------------------------------
    # ● 転送元ビットマップ:エネミー
    #--------------------------------------------------------------------------
    def update_bitmap_enemy
    if @battler.battler_name != @battler_name or @battler.battler_hue != @battler_hue
    @battler_name = @battler.battler_name
    @battler_hue = @battler.battler_hue
    @battler_graphic_file_index = @battler.sv.graphic_file_index
    @graphic_mirror_flag = @battler.sv.graphic_mirror_flag
    self.bitmap = Cache.battler(@battler_name + @battler_graphic_file_index, @battler_hue)
    @battler.sv.setup(self.bitmap.width, self.bitmap.height, @battler_id != @battler.id)
    create_shadow
    init_visibility
    @battler_id = @battler.id
    end
    end
    #--------------------------------------------------------------------------
    # ● 転送元ビットマップ:アクター
    #--------------------------------------------------------------------------
    def update_bitmap_actor
    if @battler.character_name != @battler_name or @battler.character_index != @battler_index
    @battler_name = @battler.character_name
    @battler_index = @battler.character_index
    @battler_graphic_file_index = @battler.sv.graphic_file_index
    @graphic_mirror_flag = @battler.sv.graphic_mirror_flag
    self.bitmap = Cache.character(@battler_name + @battler_graphic_file_index)
    @battler.sv.setup(self.bitmap.width, self.bitmap.height, @battler_id != @battler.id)
    create_shadow
    init_visibility
    @battler_id = @battler.id
    end
    end
    #--------------------------------------------------------------------------
    # ● 可視状態の初期化 ★再定義
    #--------------------------------------------------------------------------
    def init_visibility
    @battler_visible = @battler.alive?
    @battler_visible = true if @battler.sv.state(1) != "敵コラプス"
    @battler_visible = false if @battler.hidden?
    @battler.sv.opacity = 0 unless @battler_visible
    self.opacity = 0 unless @battler_visible
    self.opacity = 255 if @battler_visible
    @battler.sv.weapon_visible = @battler_visible
    end
    #--------------------------------------------------------------------------
    # ● 転送元矩形の更新
    #--------------------------------------------------------------------------
    def update_src_rect
    return if @battler.sv.collapse
    if @battler_graphic_file_index != @battler.sv.graphic_file_index
    @battler_graphic_file_index = @battler.sv.graphic_file_index
    self.bitmap = Cache.character(@battler_name + @battler_graphic_file_index) if @battler.actor?
    self.bitmap = Cache.battler(@battler_name + @battler_graphic_file_index, @battler_hue) if !@battler.actor?
    @battler.sv.set_graphics(self.bitmap.width, self.bitmap.height)
    end
    anime_off if @battler.sv.anime_off
    self.src_rect.set(@battler.sv.sx, @battler.sv.sy, @battler.sv.cw, @battler.sv.ch)
    self.opacity = @battler.sv.opacity if @battler_visible
    set_process_timing(@battler.sv.timing) if @battler && @battler.sv.timing != []
    end
    #--------------------------------------------------------------------------
    # ● 位置の更新 ★再定義
    #--------------------------------------------------------------------------
    def update_position
    @real_x = @battler.sv.x / 100
    @real_y = (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.c - @battler.sv.oy_adjust)/ 100
    self.x = @real_x - $sv_camera.x
    self.y = @real_y - $sv_camera.y
    self.z = @battler.sv.z - @battler.sv.c / 100
    if @battler.sv.h <= 0
    self.x += $sv_camera.sx / 100
    self.y += $sv_camera.sy / 100
    end
    self.x *= $sv_camera.zoom
    self.y *= $sv_camera.zoom
    end
    #--------------------------------------------------------------------------
    # ● 原点の更新 ★再定義
    #--------------------------------------------------------------------------
    def update_origin
    return if !bitmap or @battler.sv.collapse
    self.ox = @battler.sv.ox
    self.oy = @battler.sv.oy
    self.angle = @battler.sv.angle
    self.zoom_x = @battler.sv.zoom_x * $sv_camera.zoom
    self.zoom_y = @battler.sv.zoom_y * $sv_camera.zoom
    self.mirror = @battler.sv.mirror if !@graphic_mirror_flag
    self.mirror = !@battler.sv.mirror if @graphic_mirror_flag
    end
    #--------------------------------------------------------------------------
    # ● 影グラフィックの更新
    #--------------------------------------------------------------------------
    def update_shadow
    @shadow.visible = @battler.sv.shadow_visible
    @shadow.opacity = @battler.sv.opacity if @battler.sv.opacity_data[3]
    @shadow.opacity = self.opacity if !@battler.sv.opacity_data[3]
    @shadow.x = @real_x - $sv_camera.x
    @shadow.y = (@battler.sv.y - @battler.sv.c)/ 100 - $sv_camera.y
    @shadow.z = @battler.sv.z - 10
    @shadow.zoom_x = $sv_camera.zoom
    @shadow.zoom_y = $sv_camera.zoom
    @shadow.x += $sv_camera.sx / 100
    @shadow.y += $sv_camera.sy / 100
    @shadow.x *= $sv_camera.zoom
    @shadow.y *= $sv_camera.zoom
    @shadow.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
    end
    #--------------------------------------------------------------------------
    # ● ふきだしの更新
    #--------------------------------------------------------------------------
    def update_balloon
    if @battler.sv.balloon_data == [] && @balloon
    @balloon_data = []
    @balloon.dispose
    return @balloon = nil
    elsif @battler.sv.balloon_data != [] && @battler.sv.balloon_data != @balloon_data
    @balloon_data = @battler.sv.balloon_data
    @balloon = Sprite.new(self.viewport)
    @balloon.bitmap = Cache.system("Balloon")
    @balloon.zoom_x = @balloon_data[3]
    @balloon.zoom_y = @balloon_data[3]
    @balloon.ox = 32 if @battler.sv.mirror
    @balloon.oy = 16
    @balloon_count = 0
    end
    return if !@balloon
    @balloon.opacity = self.opacity
    @balloon.x = self.x
    @balloon.y = self.y - @battler.sv.ch * $sv_camera.zoom
    @balloon.z = self.z + 20
    @balloon.src_rect.set(32 + @balloon_count / @balloon_data[2] * 32, @balloon_data[1] * 32, 32, 32) if @balloon_count % @balloon_data[2] == 0
    @balloon.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
    @balloon_count += 1
    @balloon_count = 0 if @balloon_count == @balloon_data[2] * 7
    end
    #--------------------------------------------------------------------------
    # ● 色調変更の更新
    #--------------------------------------------------------------------------
    def update_color
    color_set if @battler.sv.color_set != []
    return if @color_data == nil
    @color_data[4] -= 1
    if @color_data[4] == 0 && @color_data[5] != 0
    @color_data[4] = @color_data[5]
    @color_data[5] = 0
    @color_data[6] = [0,0,0,0]
    elsif @color_data[4] == 0
    @remain_color_data = @color_data
    @battler.sv.color = @color_data.dup
    return @color_data = nil
    end
    for i in 0..3
    @color_data[i] = (@color_data[i] * (@color_data[4] - 1) + @color_data[6][i]) / @color_data[4]
    end
    @battler.sv.color = @color_data.dup
    self.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3])
    end
    #--------------------------------------------------------------------------
    # ● 残像の更新
    #--------------------------------------------------------------------------
    def update_mirage
    if @battler.sv.mirage == [] && @mirages
    @mirage_data = []
    for mirage in @mirages do mirage.dispose end
    return @mirages = nil
    elsif @battler.sv.mirage != [] && @battler.sv.mirage != @mirage_data
    @mirage_data = @battler.sv.mirage
    @mirages = []
    for i in 0...@mirage_data[1] do @mirages[i] = Sprite.new(self.viewport) end
    @mirage_count = 0
    end
    return if !@mirages
    @mirage_count += 1
    @mirage_count = 0 if @mirage_count == @mirage_data[2] * @mirages.size
    for i in 0...@mirages.size
    mirage_body(@mirages[i], @mirage_data[4]) if @mirage_count == 1 + i * @mirage_data[2]
    end
    end
    #--------------------------------------------------------------------------
    # ● 残像本体
    #--------------------------------------------------------------------------
    def mirage_body(body, opacity)
    body.bitmap = self.bitmap.dup
    body.x = self.x
    body.y = self.y
    body.ox = self.ox
    body.oy = self.oy
    body.z = self.z - 20
    body.mirror = self.mirror
    body.angle = self.angle
    body.opacity = opacity * self.opacity / 255
    body.zoom_x = self.zoom_x
    body.zoom_y = self.zoom_y
    body.src_rect.set(@battler.sv.sx, @battler.sv.sy, @battler.sv.cw, @battler.sv.ch)
    body.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
    end
    #--------------------------------------------------------------------------
    # ● 次のアニメを更新
    #--------------------------------------------------------------------------
    def update_next_anime
    return if !@next_anime
    for anime in @next_anime
    anime.update
    anime.set_position(self.z, self.zoom_x, self.zoom_y, @real_x, @real_y) if @horming
    anime.dispose if !anime.animation?
    @next_anime.delete(anime) if !anime.animation?
    end
    end
    #--------------------------------------------------------------------------
    # ● フレーム更新
    #--------------------------------------------------------------------------
    alias update_sprite_battler_n03 update
    def update
    @battler.sv.update if @battler
    update_sprite_battler_n03
    update_next_anime
    update_shadow if @battler && @shadow
    update_mirage if @battler
    update_balloon if @battler
    update_remove if @battler && @removing && @battler.sv.change_up
    end
    #--------------------------------------------------------------------------
    # ● 戦闘アニメ消去
    #--------------------------------------------------------------------------
    def anime_off
    @battler.sv.anime_off = false
    dispose_animation
    for anime in @next_anime do anime.dispose_animation end if @next_anime
    end
    #--------------------------------------------------------------------------
    # ● バトラー入れ替え
    #--------------------------------------------------------------------------
    def remove
    @battler.sv.start_action(@battler.sv.remove_action )
    $sv_camera.wait = 40
    @battler.sv.add_action("eval('set_change')")
    @removing = true
    end
    #--------------------------------------------------------------------------
    # ● バトラー入れ替えの更新
    #--------------------------------------------------------------------------
    def update_remove
    @battler.sv.change_up = false
    @removing = false
    @battler = nil
    end
    #--------------------------------------------------------------------------
    # ● バトラー加入
    #--------------------------------------------------------------------------
    def join(join_battler)
    $sv_camera.wait = 30
    @battler = join_battler
    @battler_name = @battler.character_name
    @battler_index = @battler.character_index
    @battler_graphic_file_index = @battler.sv.graphic_file_index
    self.bitmap = Cache.character(@battler_name)
    @battler.sv.setup(self.bitmap.width, self.bitmap.height, true)
    create_shadow
    init_visibility
    end
    #--------------------------------------------------------------------------
    # ● 通常の設定に戻す ★再定義
    #--------------------------------------------------------------------------
    def revert_to_normal
    self.blend_type = 0
    self.opacity = 255
    end
    #--------------------------------------------------------------------------
    # ● 崩壊エフェクトの更新
    #--------------------------------------------------------------------------
    alias update_collapse_sprite_battler_n03 update_collapse
    def update_collapse
    return if @battler.sv.state(1) != "敵コラプス"
    update_collapse_sprite_battler_n03
    @battler.sv.weapon_visible = false
    end
    #--------------------------------------------------------------------------
    # ● ボス崩壊エフェクトの更新 ★再定義
    #--------------------------------------------------------------------------
    def update_boss_collapse
    @effect_duration = @battler.sv.ch if @effect_duration >= @battler.sv.ch
    alpha = @effect_duration * 120 / @battler.sv.ch
    self.ox = @battler.sv.cw / 2 + @effect_duration % 2 * 4 - 2
    self.blend_type = 1
    self.color.set(255, 255, 255, 255 - alpha)
    self.opacity = alpha
    self.src_rect.y -= 1
    Sound.play_boss_collapse2 if @effect_duration % 20 == 19
    end
    #--------------------------------------------------------------------------
    # ● 別スプライトからのタイミング処理
    #--------------------------------------------------------------------------
    def set_process_timing(timing_data)
    for data in timing_data
    set_timing(data[0],data[1])
    end
    @battler.sv.timing = []
    end
    #--------------------------------------------------------------------------
    # ● タイミング処理
    #--------------------------------------------------------------------------
    def set_timing(se_flag, data)
    @ani_rate = 4
    data.se.play if se_flag
    case data.flash_scope
    when 1 ;self.flash(data.flash_color, data.flash_duration * @ani_rate)
    when 2 ;viewport.flash(data.flash_color, data.flash_duration * @ani_rate) if viewport
    when 3 ;self.flash(nil, data.flash_duration * @ani_rate)
    end
    end
    #--------------------------------------------------------------------------
    # ● 色調変更
    #--------------------------------------------------------------------------
    def color_set
    set = @battler.sv.color_set
    @battler.sv.color_set= []
    set[4] = 1 if set[4] == 0
    @remain_color_data = [0,0,0,0] if @remain_color_data == nil
    @color_data = @remain_color_data
    @color_data[4] = set[4]
    @color_data[5] = set[5]
    @color_data[6] = set
    end
    #--------------------------------------------------------------------------
    # ● 解放
    #--------------------------------------------------------------------------
    alias dispose_sprite_battler_n03 dispose
    def dispose
    dispose_sprite_battler_n03
    @shadow.dispose if @shadow != nil
    @balloon.dispose if @balloon != nil
    for mirage in @mirages do mirage.dispose end if @mirages != nil
    for anime in @next_anime do anime.dispose end if @next_anime
    end
    end


    #================================================= =============================
    # ■ Spriteset_Battle
    #------------------------------------------------------------------------------
    #  バトル画面のスプライトをまとめ クラスです。
    #================================================= =============================
    class Spriteset_Battle
    #--------------------------------------------------------------------------
    # ● 戦闘背景(床)スプライトの作成 ★再定義
    #--------------------------------------------------------------------------
    def create_battleback1
    @back1_sprite = Sprite_Battle_Back.new(@viewport1, 1, battleback1_name)
    @back1_sprite.set_graphics(battleback1_bitmap) if battleback1_name != nil
    @back1_sprite.z = 0
    end
    #--------------------------------------------------------------------------
    # ● 戦闘背景(壁)スプライトの作成 ★再定義
    #--------------------------------------------------------------------------
    def create_battleback2
    @back2_sprite = Sprite_Battle_Back.new(@viewport1, 2, battleback2_name)
    @back2_sprite.set_graphics(battleback2_bitmap) if battleback2_name != nil
    @back2_sprite.z = 1
    end
    #--------------------------------------------------------------------------
    # ● アクタースプライトの作成 ★再定義
    #--------------------------------------------------------------------------
    def create_actors
    @actor_sprites = []
    for i in 0...$game_party.max_battle_members
    @actor_sprites[i] = Sprite_Battler.new(@viewport1, $game_party.members[i])
    end
    @effect_sprites = Spriteset_Sideview.new(@viewport1)
    end
    #--------------------------------------------------------------------------
    # ● アクタースプライトの更新 ★再定義
    #--------------------------------------------------------------------------
    def update_actors
    @actor_sprites.each_with_index do |sprite, i|
    sprite_join($game_party.members[i], sprite) if sprite.battler == nil && sprite.battler != $game_party.members[i]
    sprite.remove if sprite.battler != nil && !sprite.removing && sprite.battler != $game_party.members[i]
    sprite.update
    end
    @effect_sprites.update
    update_program
    end
    #--------------------------------------------------------------------------
    # ● メンバーを加える
    #--------------------------------------------------------------------------
    def sprite_join(member, sprite)
    for sp in @actor_sprites
    sp.update_remove if member == sp.battler && !sp.battler.sv.change_up
    end
    sprite.join(member)
    end
    #--------------------------------------------------------------------------
    # ● バトルプログラムの更新
    #--------------------------------------------------------------------------
    def update_program
    return if $sv_camera.program_scroll == []
    for data in $sv_camera.program_scroll
    @back1_sprite.start_back_data(data) if data[2] == 1
    @back2_sprite.start_back_data(data) if data[2] == 2
    end
    $sv_camera.program_scroll = []
    end
    #--------------------------------------------------------------------------
    # ● ヒット時の戦闘アニメ実行
    #--------------------------------------------------------------------------
    def set_hit_animation(battler, weapon_index, hit_targets, miss)
    @effect_sprites.set_hit_animation(battler, weapon_index, hit_targets, miss)
    end
    #--------------------------------------------------------------------------
    # ● ダメージPOP
    #--------------------------------------------------------------------------
    def set_damage_pop(target)
    @effect_sprites.set_damage_pop(target)
    end
    #--------------------------------------------------------------------------
    # ● 解放
    #--------------------------------------------------------------------------
    alias dispose_spriteset_battle_n03 dispose
    def dispose
    dispose_spriteset_battle_n03
    @effect_sprites.dispose
    end



    end


    #================================================= =============================
    # ■ Window_BattleLog
    #------------------------------------------------------------------------------
    #  戦闘の進行を実況表示するウィン ウです。
    #================================================= =============================
    class Window_BattleLog < Window_Selectable
    #--------------------------------------------------------------------------
    # ● ウェイト ★再定義
    #--------------------------------------------------------------------------
    def wait
    end
    #--------------------------------------------------------------------------
    # ● ウェイトとクリア ★再定義
    #--------------------------------------------------------------------------
    def wait_and_clear
    $sv_camera.wait = 10
    end
    #--------------------------------------------------------------------------
    # ● 行動結果の表示 ★再定義
    #--------------------------------------------------------------------------
    def display_action_results(target, item)
    if target.result.used
    last_line_number = line_number
    display_critical(target, item)
    display_damage(target, item)
    display_affected_status(target, item)
    display_failure(target, item)
    end
    off if !N03::BATTLE_LOG
    end
    #--------------------------------------------------------------------------
    # ● ウインドウ非表示
    #--------------------------------------------------------------------------
    def off
    @back_sprite.visible = self.visible = false
    end
    end
    #================================================= =============================
    # ■ Game_Interpreter
    #------------------------------------------------------------------------------
    #  イベントコマンドを実行するイン プリタです。
    #================================================= =============================
    class Game_Interpreter
    #--------------------------------------------------------------------------
    # ● スイッチの操作
    #--------------------------------------------------------------------------
    alias command_121_game_interpreter_n03 command_121
    def command_121
    command_121_game_interpreter_n03
    $sv_camera.program_check
    end
    end
    Что в скрипте делают смайлики?

  4. #844
    Маститый Аватар для Рыб
    Информация о пользователе
    Регистрация
    12.11.2008
    Адрес
    Маленькая гордая стана в центре Европы[точка]
    Сообщений
    1,381
    Записей в дневнике
    49
    Репутация: 52 Добавить или отнять репутацию

    По умолчанию

    Если ты ничего не забыл то команда
    spawn_event(_map_id, _event_id, _x, _y)

    Event Spawner
    _map_id: ID карты, где находиться евент
    _event_id: ID евента
    _x: X координата вставки евента
    _y: Y координата вставки евента
    #
    # Returns: New Event ID
    Конференция со свободным входом:

    но Я БЫ ВЫБРАЛ РЕСЛИНГ"

  5. #845

    По умолчанию

    Цитата Сообщение от Soliд Посмотреть сообщение
    Что в скрипте делают смайлики?
    attr_accessor : ox
    attr_accessor : oy
    это с пробелом, уберешь будут смайлики, форум меняет сам.
    attr_accessor x
    attr_accessor y

  6. #846
    Маститый Аватар для Antberg
    Информация о пользователе
    Регистрация
    14.04.2008
    Сообщений
    1,241
    Записей в дневнике
    3
    Репутация: 49 Добавить или отнять репутацию

    По умолчанию

    Кто-нибудь знает, как на ХР сделать так, что-бы кнопка Enter была равнозначна кнопке Z? Пробовал везде в скриптах заменить "Input::C" на "Input::A" ("A" в ХР означает "Z"), но таким образом удалось просто назначить функцию "решение" на кнопку "Z", в то время как Enter перестал работать. И похоже, работает он только с кнопкой "С". Может, как-то всё-же эта проблема решается?

  7. #847
    Местный Аватар для SethNsk
    Информация о пользователе
    Регистрация
    25.03.2010
    Сообщений
    235
    Записей в дневнике
    7
    Репутация: 12 Добавить или отнять репутацию

    По умолчанию

    Цитата Сообщение от Рыб Посмотреть сообщение
    Если ты ничего не забыл то команда
    spawn_event(_map_id, _event_id, _x, _y)

    Event Spawner
    _map_id: ID карты, где находиться евент
    _event_id: ID евента
    _x: X координата вставки евента
    _y: Y координата вставки евента
    #
    # Returns: New Event ID
    Огромное спасибо! Не мог догнать как должна выглядеть команда... Обычно она написана, а тут то ли не заметил, то ли пора знать... =)

  8. #848
    Маститый Аватар для The Joker
    Информация о пользователе
    Регистрация
    16.06.2008
    Сообщений
    1,209
    Записей в дневнике
    11
    Репутация: 29 Добавить или отнять репутацию

    По умолчанию

    2rammsteks.
    Скорее всего, дело все-таки не в скрипте. Думаю, тебе стоить в таком случае обратить внимание на поле Заметки (Notes) на вкладке Навыков.
    Damaged

  9. #849

    По умолчанию

    Цитата Сообщение от The Joker Посмотреть сообщение
    2rammsteks.
    Скорее всего, дело все-таки не в скрипте. Думаю, тебе стоить в таком случае обратить внимание на поле Заметки (Notes) на вкладке Навыков.
    они пустые

    тут еще 2 куска скрипта от sidewiev

    Спойлер 1:
    #================================================= =============================
    # ■ SideViewアクション設定 Ver100
    #------------------------------------------------------------------------------
    #  サイドビューバトル全般のセッテ ングやアクションを作成します
    #================================================= =============================
    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 = 8
    # ターン終了時のウエイト(待ち時間・ 位は1フレーム)
    TURN_END_WAIT = 12
    # 敵の不意打ち時にバックアタック(左 反転)を許可するならtrue しないならfalse
    BACK_ATTACK = true
    # 味方バトラーがダメージを受けた時 デフォルトのエフェクトを採用する らtrue
    ACTOR_DAMAGE = false
    # 敵バトラーがダメージを受けた時、 フォルトのエフェクトを採用するな true
    ENEMY_DAMAGE = false
    # 敵バトラーのX座標、回転計算、戦闘 ニメを自動で反転させるならtrue
    ENEMY_MIRROR = true
    # コラプス禁止処理に使う、データベ スの不死身ステートID
    IMMORTAL_ID = 10

    # バトルログ(戦闘の進行を実況表示す ウィンドウ)を表示させるならtrue
    # OFFにした場合、スキル名ウインドウ 画面上部に表示されます
    BATTLE_LOG = true
    # スキル名ウインドウON時の、非表示に するスキルIDを配列に入れます
    NO_DISPLAY_SKILL_ID = [1,2,3,4,5,6,7]
    # ダメージ数字をPOPさせるならtrue
    DAMAGE_POP = true
    # ステート付加をPOPさせるならtrue
    STATE_POP = true
    # ダメージ数字画像のファイル名(System ォルダを参照します)
    DAMAGE_PLUS = "damage_num+"
    # 回復数字画像のファイル名(Systemフォ ダを参照します)
    DAMAGE_MINUS = "damage_num-"
    # MPダメージ数字画像のファイル名(Syste mフォルダを参照します)
    DAMAGE_MP = "damage_mp"
    # TPダメージ数字画像のファイル名(Syste mフォルダを参照します)
    DAMAGE_TP = "damage_tp"
    # ダメージ数字の文字間隔を調整
    DAMAGE_ADJUST = -4

    # 戦闘カメラのフォーカス(移動先の焦 )を調整 [X軸, Y軸]
    CAMERA_POSITION = [ 0, -40]

    #--------------------------------------------------------------------------
    # ● 戦闘背景セッティング 背景の座標調整や拡大率を設定しま
    #--------------------------------------------------------------------------
    # 床背景ファイル名…設定する床背景(B attlebacks1)画像ファイル名。
    # "全Battlebacks1"は指定のないBattlebacks1画 像を一括設定する項目です
    # 壁背景ファイル名…設定する壁背景(B attlebacks2)画像ファイル名。
    # "全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軸…手前に表示するならプラス。通 は画面下ほど手前に表示されます
    # ウエイト…アニメパターンが最後ま 再生されてから次の行動に移るならt rue
    # 影…影グラフィックを表示するならtr ue、しない場合は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, 10, true, true, "" ],
    "右向き移動" => ["motion", "", 2, 0, 4, 6, 10, true, true, "" ],

    #―アクション名(ポーズ系)― 判別 ファイルNo 縦セル 横セル パターン 速度 Z軸 ウエイト 影 武器
    "武器掲げ" => ["motion", "", 1, 0, 1, 2, 200,false, true, "掲げ" ],

    #―アクション名(攻撃系)― 判別 ファイル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, "弓"],

    #--------------------------------------------------------------------------
    # ● バトラー移動 エネミーの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, 180, 0, 0, 0, 0, [ 0, 0], "左向き移動"],
    "退場" => ["move",-7, 180, 0, 0, 7, 0, [ 0, 0], "右向き移動"],
    "逃走途中" => ["move",-7, 80, 0, 0, 7, 0, [ 0, 0], "右向き移動"],
    "コマンド入力移動" => ["move",-7, -20, 0, nil,-10, 0, [ 0, 0], "左向き移動"],
    "ダメージのけぞり" => ["move", 0, 20, 0, nil,-10, 0, [ 0, 0], ""],
    "ダメージのけぞり大" => ["move", 0, 60, 0, nil,-10, 0, [ 0, 0], ""],

    #――アクション名(リセット系)―― 判別 目標 X軸 Y軸 H軸 速度 カーブ ジャンプ アニメ
    "座標リセット早" => ["move",-7, 0, 0, 0,-10, 0, [ 0, 0], "右向き移動"],
    "座標リセット" => ["move",-7, 0, 0, 0,-20, 0, [ 0, 0], "右向き移動"],
    "座標リセットカーブ" => ["move",-7, 0, 0, 0,-20, -2, [ 0, 0], "右向き移動"],
    "座標リセット左向き" => ["move",-7, 0, 0, 0,-20, 0, [ 0, 0], "左向き移動"],

    #――アクション名(自身系)―― 判別 目標 X軸 Y軸 H軸 速度 カーブ ジャンプ アニメ
    "一歩前移動" => ["move", 0, -20, 0, 0,-10, 0, [ 0, 0], "左向き移動"],
    "一歩後移動" => ["move", 0, 20, 0, 0,-10, 0, [ 0, 0], "左向き移動"],
    "一歩前ジャンプ" => ["move", 0, -30, 0, 0,-10, 0, [ 20,-20], "左向き移動"],
    "一歩後ジャンプ" => ["move", 0, 30, 0, 0,-10, 0, [ 20,-20], "左向き移動"],
    "勝利ジャンプ" => ["move", 0, 10, 0, 0,-25, 0, [ 30,-30], "待機固定"],
    "勝利ジャンプ武器" => ["move", 0, 0, 0, 0,-15, 0, [ 20, 0], "武器掲げ"],
    "勝利ジャンプ着地" => ["move",-7, 0, 0, 0,-10, 0, [ 0, 0], "武器振りR"],
    "縦揺れ01" => ["move", 0, 0, 0, 20, -2, 0, [ 0, 0], ""],
    "縦揺れ02" => ["move", 0, 0, 0, -20, -2, 0, [ 0, 0], ""],

    #――アクション名(目標系)―― 判別 目標 X軸 Y軸 H軸 速度 カーブ ジャンプ アニメ
    "敵前移動" => ["move", 1, 30, 0, 0,-20, 0, [ 0, 0], "左向き移動"],
    "敵後移動" => ["move", 1, -60, 0, 0,-20, 0, [ 0, 0], "左向き移動"],
    "敵中移動早" => ["move", 1, 0, 0, 0,-10, 0, [ 0, 0], "左向き移動"],
    "叩き付け前ジャンプ" => ["move",-1, 0, 0, 100,-20, 0, [ 40,-20], "武器掲げ"],
    "叩き付け" => ["move",-1, 0, 0, 0,-10, 0, [ 0, 0], "武器振りR"],

    #--------------------------------------------------------------------------
    # ● 武器アクション バトラーアニメや 器・アニメ飛ばしに利用するアクシ ン
    #--------------------------------------------------------------------------
    # タイプ…[0…アイコン利用]
    # [1…独自画像(画像名はバトラー設定 の武器の項目で行います。参照先はCh aractersフォルダ)]
    # [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。[移動させるアニメID, ヒット時のアニメID] 0はアニメ非表示、-1は武器のアニメを表示。
    # 始…アニメ移動の開始位置。マイナ にすると、複数ターゲットでも一 のアニメだけ実行
    # [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軸 ウエイト ダメージ ホーミング カメラ ループ 反転不可 武器
    "矢発射WT" => ["m_a",[ 0,-1], 0, 1, [ 0, 0], [ 0, 0], 10, 2, [-3,-3], true, [ true, true], true, true, true, false, false, "矢"],
    "矢発射" => ["m_a",[ 0,-1], 0, 1, [ 0, 0], [ 0, 0], 10, 2, [-3,-3], true, [false,false], true, true, true, false, false, "矢"],
    "水鉄砲発射" => ["m_a",[69,69], 0, 1, [ 0, 0], [ 0, 0], 10, 0, [ 0, 0], true, [ true, true], true, true, true, true, false, ""],
    "武器投げ開始" => ["m_a",[ 0,-1], 0, 1, [ 4,-6], [ 0, 0], 10, 2, [-3,-3], true, [ true,false], true, true, true, false, false, "回転"],
    "武器投げ戻し" => ["m_a",[ 0, 0], 1, 0, [ 0, 0], [ 4,-6], 10, 0, [ 3, 3], true, [ true,false], false, true, true, false, false, "回転"],

    #--------------------------------------------------------------------------
    # ● 戦闘アニメ データベースの戦闘ア メを表示します
    #--------------------------------------------------------------------------
    # ID…アニメID。-1で武器に設定されたアニメに -2は二刀流のもう片方の武器アニメに
    # -3でスキルに設定されたアニメに
    # 対象…[0=自分] [1=ターゲット] [2=敵全] [3=味方全] [4=敵味方全] [5=セカンドターゲット]
    # ホーミング… 対象の座標移動にアニメが追尾する らtrue
    # ウエイト…アニメ表示が終わるまで つならtrue
    # ダメージ…ダメージ計算を適用 るならtrue
    # カメラ…カメラのズームに合わせて ニメを拡大縮小するならtrue
    # 反転不可…いかなる場合でもアニメ 反転させないならtrue
    # 反転…アニメを反転させるならtrue
    # Z軸…アニメをキャラより手前に表示 るならtrue

    #―アクション名(ダメージ系)― 判別 ID 対象 ホーミング ウエイト ダメージ カメラ 反転不可 反転 Z軸
    "対象アニメ武器" => ["anime", -1, 1, false, false, true, true, false, false, true],
    "対象アニメ武器WT" => ["anime", -1, 1, false, true, true, true, false, false, true],
    "対象アニメ武器LWT" => ["anime", -2, 1, false, true, true, true, false, false, true],
    "対象アニメ" => ["anime", -3, 1, false, false, true, true, false, false, true],
    "対象アニメWT" => ["anime", -3, 1, false, true, true, true, false, false, true],

    #――アクション名(自身系)―― 判別 ID 対象 ホーミング ウエイト ダメージ カメラ 反転不可 反転 Z軸
    "魔法詠唱中" => ["anime", 113, 0, true, true, false, true, false, false, true],
    "特技待機中" => ["anime", 114, 0, true, true, false, true, false, false, true],
    "魔法発動アニメ" => ["anime", 115, 0, false, true, false, true, false, false, false],
    "特技発動アニメ" => ["anime", 116, 0, false, true, false, true, false, false, false],

    #--------------------------------------------------------------------------
    # ● カメラワーク 画面のズームやスクロールを行いま
    #--------------------------------------------------------------------------
    # 対象…移動やズームの対象
    # [0=自分] [1=ターゲット] [2=敵全] [3=味方全] [4=敵味方全] [5=セカンドターゲット] [6=画面]
    # 調整座標…カメラ座標の最終地点微 整 [X軸(プラスで画面→), Y軸(プラスで画面↓)]
    # 時間…カメラワークにかける時間
    # ズーム…カメラのズーム率(%)。100 ズームなし。
    # ウエイト…カメラワークが終わるま 待つならtrue。待たないならfalse

    #――アクション名―― 判別 対象 調整座標 ズーム 時間 ウエイト
    "カメラリセット"=> ["camera", 6, [ 0, 0], 100, 40, false],
    "ズームイン" => ["camera", 6, [ 0, 100], 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,12], 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", 6, [ 0, 0, 0, 255, 30, 0], false],
    "自分とターゲット以外暗転" => ["color", 9, [ 0, 0, 0, 255, 30, 0], false],

    #--------------------------------------------------------------------------
    # ● トランジション 画面を固定した後 実行するトランジションです
    #--------------------------------------------------------------------------
    # 実行する前にアクション"画面固定"を 実行し、画面を固定させてください
    #
    # 境界…境界の曖昧さ。値が大きいほ 曖昧になります
    # 時間…トランジションにかける時間 トランジション中はゲーム画面は固 されます
    # トランジションファイル名…トラ ジション画像。Picturesフォルダに入 てください

    #―――アクション名――― 判別 境界 時間 トランジションファイル名
    "サークル" => ["ts", 40, 60, "circle"],

    #--------------------------------------------------------------------------
    # ● 残像 バトラーの移動に残像を残します
    #--------------------------------------------------------------------------
    # 数…残像数。0は表示中の残像を消し す。あまり多いと負荷が高くなりま す
    # 間隔…残像の表示間隔。小さいほど い。単位は1フレーム
    # 処理…残像の後処理。trueはフルアク ョン終了時に消え、falseは消えずに っと表示
    # 透明度…残像の透明度

    #――アクション名―― 判別 数 間隔 処理 透明度
    "残像ON" => ["mirage", 4, 3, true, 160],
    "残像OFF" => ["mirage", 0, 0, true, 0],

    #--------------------------------------------------------------------------
    # ● バトラー回転 画像を回転
    #--------------------------------------------------------------------------
    # 回転しているバトラーのフルアクシ ンが終了すると、回転角度はリセッ されます
    # 回転中の画像転送元原点は中心にな ます。反転と違い、武器アクション 反映されません
    #
    # 時間…回転にかける時間。0で即座に 映されます
    # 始度…回転開始時の角度。0~360度を 定。正が反時計周り、負が時計周り
    # 終度…回転終了時の角度。0~360度を 定。上記ともにエネミーは逆計算に なります
    # タイプ…回転終了後の処理。[0…回転リセット] [1…終了角度のまま] [2…ループ]

    #――アクション名――   判別 時間 始度 終度 タイプ
    "右1回転" => ["angle", 12, 0, -360, 0],
    "左1回転" => ["angle", 12, 0, 360, 0],

    #--------------------------------------------------------------------------
    # ● バトラー拡大縮小 画像を拡大縮小
    #--------------------------------------------------------------------------
    # 拡大縮小しているバトラーのフルア ションが終了すると、拡大縮小はリ ットされます
    # 反転と違い、武器アクションは反映 れません
    #
    # 時間…拡大縮小にかける時間。
    # 開始サイズ…拡大縮小開始時のサ ズ。小数点で入れてください。[X軸(横), Y軸(縦)]
    # 終了サイズ…拡大縮小終了時のサ ズ。小数点で入れてください。[X軸(横), Y軸(縦)]
    # タイプ…拡大縮小終了後の処理。[0…サイズリセット] [1…終了サイズのまま] [2…ループ]

    #――アクション名――   判別 時間 開始サイズ 終了サイズ タイプ
    "横縮み" => ["zoom", 12, [1.0, 1.0], [0.5, 1.0], 0],
    "縦縮み" => ["zoom", 12, [1.0, 1.0], [1.0, 0.5], 0],

    #--------------------------------------------------------------------------
    # ● バトラー透明度操作 画像の透明度 変更
    #--------------------------------------------------------------------------
    # 透明度操作しているバトラーのフル クションが終了すると、透明度操作 リセットされます
    #
    # 時間…透明度変更にかける時間。
    # 開始…変更開始時の透明度。0が完全 消えた状態、255が完全に不透明な状 態
    # 終了…変更終了時の透明度
    # 影…影も同じ透明度操作をするならtr ue
    # 武器…武器も同じ透明度操作をする ら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
    # インデックス…アクターの場合、 行グラのどの矩形かを設定します
    # [0][1][2][3]
    # [4][5][6][7]
    #
    # ファイル名…変更する画像ファイル 。アクターはCharactersフォルダ、
    # エネミーはBattlersフォルダを参照しま す
    # 顔グラ…アクターの場合、戦闘後 顔グラも変更するなら[顔グラインデックス, ファイル名]
    # 変更しないなら[]

    #―――アクション名――― 判別 維持 インデックス ファイル名 顔グラ
    "オオカミに変身" => ["change", false, 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"],

    #--------------------------------------------------------------------------
    # ● ゲームスイッチ(サイドビュー専用ス ッチ)の操作
    #--------------------------------------------------------------------------
    # IDがプラスでゲームスイッチ、マイナ スでサイドビュー専用スイッチの操 になります
    #
    # ON番号…ONにするスイッチIDをまとめ 配列に入れます
    # OFF番号…OFFにするスイッチIDをまとめ て配列に入れます
    #
    #――アクション名―― 判別 ON番号 OFF番号
    "スイッチNo1/ON" => ["switch", [ 1], []],
    "背景を宇宙に変更"=> ["switch", [-4], []],
    "背景宇宙を解除" => ["switch", [], [-4]],
    "魔方陣ON" => ["switch", [-5], []],
    "魔方陣OFF" => ["switch", [], [-5]],

    #--------------------------------------------------------------------------
    # ● ゲーム変数の操作
    #--------------------------------------------------------------------------
    # 変数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・M P・TP限定)
    # 条件…参照したパラメータが条件 数字と比べて…[0=同じ] [1=少ない] [2=多い]
    # 人数…上の条件となる必要人数。条 対象がグループの場合、0でグループ 全員の数になります
    # 分岐…条件を満たした場合の分岐処 。満たさない場合はその逆の処理が れます
    # [0=次のアクションを実行] [1=次のアクションをキャンセル] [2=フルアクション終了]
    #
    #―――アクション名――― 判別 対象 種別 数値 条件 人数 分岐
    "HP50%以上で実行" => ["n_5", 0, 4, -50, 2, 1, 0],

    #--------------------------------------------------------------------------
    # ● 条件分岐 (装備)
    #--------------------------------------------------------------------------
    # 対象…条件を参照する対象 [0=自分] [1=ターゲット] [2=敵全体] [3=味方全体] [4=敵味方全体] [5=セカンドターゲット]
    # 種類…条件となる装備の種類 [0=武器] [1=防具]
    # 装備ID…上の種類のアイテムID。IDは 括して配列[]に入れます。
    # マイナスで武器(防具)タイプを参照し ます
    # 条件…[0=装備している] [1=装備していない]
    # 人数…上の条件となる必要人数。条 対象がグループの場合、0でグループ 全員の数になります
    # 分岐…条件を満たした場合の分岐処 。満たさない場合はその逆の処理が れます
    # [0=次のアクションを実行] [1=次のアクションをキャンセル] [2=フルアクション終了]
    #
    #―――アクション名――― 判別 対象 種類 ID 条件 人数 分岐
    "ハンドアクス限定" => ["n_6", 0, 0, [1], 0, 1, 0],
    "拳限定" => ["n_6", 0, 0, [-2], 0, 1, 0],
    "拳除外" => ["n_6", 0, 0, [-2], 0, 1, 1],
    "弓限定" => ["n_6", 0, 0, [-6], 0, 1, 0],
    "弓除外" => ["n_6", 0, 0, [-6], 0, 1, 1],
    "拳弓除外" => ["n_6", 0, 0,[-2,-6], 0, 1, 1],

    #--------------------------------------------------------------------------
    # ● 条件分岐 (スクリプト) 
    #--------------------------------------------------------------------------
    # 分岐…条件を満たした場合の分岐処 。満たさない場合はその逆の処理が れます
    # [0=次のアクションを実行] [1=次のアクションをキャンセル] [2=フルアクション終了]
    # スクリプト…trueかfalseを返すスク プトを入れます
    #
    #―――アクション名――― 判別 分岐 スクリプト
    "50%の確率で実行" => ["n_7", 0, "rand(100) < 50"],
    "アクター限定" => ["n_7", 0, "@battler.actor?"],
    "アクターID1限定" => ["n_7", 0, "@battler.actor? && @battler.actor_id == 1"],
    "アクターID2限定" => ["n_7", 0, "@battler.actor? && @battler.actor_id == 2"],
    "アクターID6限定" => ["n_7", 0, "@battler.actor? && @battler.actor_id == 6"],
    "アクターID7限定" => ["n_7", 0, "@battler.actor? && @battler.actor_id == 7"],
    "エネミー限定" => ["n_7", 0, "!@battler.actor?"],
    "エネミー中止" => ["n_7", 2, "!@battler.actor?"],
    "二刀流限定" => ["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", 3, [ 0, 0], 0, 0, 0, [ 0, 0, 0], [ 0,[0]], 2, 0],
    "全域化" => ["s_t", 4, [ 0, 0], 0, -1, 0, [ 0, 0, 0], [ 0,[0]], 0, 1],

    #--------------------------------------------------------------------------
    # ● コモンイベントの呼び出し
    #--------------------------------------------------------------------------
    # ID…コモンイベントID
    # ウエイト…イベント実行中はアクシ ンをストップさせるならtrue
    #
    #―――アクション名――― 判別 ID ウエイト
    "コモンNo1" => ["common", 1, true],

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

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

    #―――アクション名――― 判別
    "戦闘アニメ消去" => ["anime_off"],
    "強制戦闘終了" => ["battle_end"],
    "画面固定" => ["graphics_freeze"],
    "ダメージアニメ" => ["damage_anime"],
    "反転" => ["mirror"],
    "武器消去" => ["weapon_off"],
    "武器消去解除" => ["weapon_on"],
    "敵コラプス" => ["normal_collapse"],
    "コラプス禁止" => ["no_collapse"],
    "コラプス禁止解除" => ["collapse"],
    "待機キャンセル" => ["non_motion"],
    "待機キャンセル解除"=> ["non_motion_cancel"],
    "初期位置変更" => ["change_base_position"],
    "初期位置変更解除" => ["set_base_position"],
    "強制" => ["force_action"],
    "強制2" => ["force_action2"],
    "次の行動者へ" => ["next_battler"],
    "個別開始" => ["individual_start"],
    "個別終了" => ["individual_end"],
    "ループ開始" => ["loop_start"],
    "ループ終了" => ["loop_end"],

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

    #--------------------------------------------------------------------------
    # ● ショートカットコマンド
    #--------------------------------------------------------------------------
    # 通常は設定したアクション名をフル クション配列に入れて行動を作りま が
    # アクション設定せず直接コマンドを 述して、作業を短縮できるものがあ ます
    # 頻繁に利用するものはこのショート ットを使うと登録アクションが増え いのでお勧めです
    #
    # [戦闘アニメ]
    # (例) "anime(20)" …データベース20番のアニメをターゲ ットに実行(ウエイトあり)
    # (例) "anime(20,false)" …データベース20番のアニメをターゲ ットに実行(ウエイトなし)
    # (例) "anime_me(20)" …データベース20番のアニメを自分に 実行(ウエイトあり)
    # (例) "anime_me(20,false)" …データベース20番のアニメを自分に 実行(ウエイトなし)
    #
    # [ウエイト インデックスディレイ] ※パーティインデックスでウ イトにディレイを掛けます
    # (例) "delay(12)"…インデックス1番のウエ トが0フレーム 2番のウエイトが12フ レーム 3番のウエイトが24フレーム…
    #
    # [効果音(SE)]
    # (例) "se('Bow1')" …ファイル名がBow1のSEを鳴らします
    # (例) "se('Bow1',50)" …ファイル名がBow1のSEをピッチ50で鳴 らします
    #
    # [ターゲットへアクション(フルアクシ ン)を強制]
    # (例) "target('ダメージのけぞり')" …ターゲットに"ダメージのけぞり" のアクションを強制します
    # (例) "target2('被ダメージ')" …セカンドターゲットに"被ダメ ジ"のフルアクションを強制します

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

    # ―――待機系―――
    "通常待機" => ["待機"],
    "通常待機固定" => ["待機固定WT"],
    "ピンチ待機" => ["状態異常/ピンチ","ピンチ色調","待機","待機"],
    "防御待機" => ["待機固定WT"],
    "毒待機" => ["状態異常/汎用","毒色調","待機","待機","エネミ 限定","80"],
    "睡眠待機" => ["状態異常/睡眠","エネミー限定","40","エネミー中 止","倒れ","倒れ"],
    "汎用状態異常待機"=> ["状態異常/汎用","汎用状態異常色調","待機","待 ","エネミー限定","80"],
    "様子見" => ["待機","60"],
    "戦闘不能" => ["倒れ"],

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

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

    # ―ショートカット系(他のフルアクシ ンから呼び出されるパーツ)―
    "斬り" => ["武器振りR","対象アニメ武器","10"],
    "拳" => ["武器拳突き","対象アニメ武器","10"],
    "弓" => ["Bow1","弓撃ち","矢発射","9"],
    "攻撃" => ["拳限定","拳","弓限定","弓","拳弓除外" ,"斬り"],
    "通常攻撃始め" => ["敵前移動","コラプス禁止","個別開始" ,"二刀流限定","二刀左"],
    "通常攻撃終わり" => ["死亡確認","対象アニメ武器WT","個別 了","コラプス禁止解除","次の行動者 ","座標リセットカーブ"],
    "二刀左" => ["武器振りL","対象アニメ武器LWT"],
    "特技発動" => ["一歩前移動","武器掲げ","特技発動ア メ"],
    "魔法発動" => ["一歩前移動","武器掲げ","魔法発動ア メ"],
    "カットイン" => ["カットイン背景始","カットイン分岐" ,"70","カットイン終","カットイン背景 ","20"],
    "カットイン分岐" => ["アクターID1限定","カットインA1","ア ターID2限定","カットインA2","アクタ ID6限定","カットインA3","アクターID7 定","カットインA4"],
    "死亡フラグ動画" => ["白フェードイン","50","死亡フラグム ビー","白フェードアウト","50"],
    "背景を宇宙に" => ["ズームアウト","se('Blind',70)","背景の 暗転","自分以外味方全員","強制2","透 明化","透明化","40","背景を宇宙に変更 ","色調初期化"],
    "背景宇宙解除" => ["カメラリセット","背景のみ暗転","targ et2('透明化解除WT')","透明化解除","40"," 背景宇宙を解除","色調初期化"],
    "魔方陣表示" => ["se('Blind',70)","画面固定","魔方陣ON","サ ークル"],
    "魔方陣消去" => ["40","画面固定","魔方陣OFF","サーク "],

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

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

    "水鉄砲" => ["特技発動","武器振りR","水鉄砲発射"," 座標リセット"],
    "武器投げ" => ["特技発動","Bow1","武器振りR","6","待機 定","武器投げ開始","武器投げ戻し"," 座標リセット"],
    "カットイン攻撃" => ["特技発動","カットイン","攻撃","座標 セット"],
    "ムービー攻撃" => ["特技発動","待機固定","死亡フラグ動 ","通常攻撃始め","武器振りR","通常 撃終わり"],
    "オオカミ変身" => ["特技発動","anime(110,false)","オオカミに 変身","待機固定","120","座標リセット"],
    "5回攻撃" => ["特技発動","コラプス禁止","弓除外"," 前移動","攻撃","攻撃","攻撃","攻撃"," 攻撃","コラプス禁止解除","座標リセ ト"],
    "スキル派生" => ["武器投げ","多段攻撃に派生","斬り攻 "],
    "背景変更攻撃" => ["魔法発動","武器振りR","背景を宇宙に ","ダメージアニメ","背景宇宙解除"," 標リセット"],
    "ピクチャ攻撃" => ["魔法発動","魔方陣表示","武器振りR"," anime(80,false)","60","シェイク大","対象ア ニメ","魔方陣消去","座標リセット"],
    "暗転攻撃" => ["特技発動","自分とターゲット以外暗 ","se('Laser',150)",
    "残像ON","敵前移動","anime(35,false)","敵 移動","対象アニメ",
    "武器振りR","20","色調初期化","座標リ ット","残像OFF"],
    "空中攻撃" => ["特技発動","Bow1","一歩前ジャンプ","叩 き付け前ジャンプ",
    "待機固定","左1回転","10","anime(117,false) ","叩き付け",
    "対象アニメ","シェイク中","強制","縦 れ","20",
    "一歩後ジャンプ","座標リセット"],

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



    }



    #================================================= =============================
    # ■ バトルプログラム
    #------------------------------------------------------------------------------
    #  バトルシーンの演出を時間管理し す
    #  制御はゲームスイッチ・サイドビ ー専用スイッチで行います
    #================================================= =============================
    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], [], 1200, 0],
    "背景を海に" => ["switch", -2, [-3], [], 2400, 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フォルダから参照します
    # 変更する背景設定は、変更前のもの 引き継ぎます
    #
    # 繋ぎ画像…背景スクロール時、背景 更を自然に見せるための繋ぎ画像フ イル名
    # スクロール途中で背景変更が行われ 場合、スクロールが終わってから変 が行われます
    # 性質上、斜めスクロールには対応し いません
    #
    # 割込み…この背景が表示されている に別の背景制御が割り込んできた場 、
    # 割込みを許可するならtrue(繋ぎ画像表 示中はスクロールなしの背景だけが 込みます)
    # 割込みを許可しないならfalse(別の背 制御は保留され、この背景が消えた に変更されます)

    #――プログラム名―― 判別 スイッチ No. スクロール速度 BA反転 画像 繋ぎ画像 割込み
    "遠景右移動" => ["scroll", -1, 1, [ 40, 0], true, "", "", true],
    "海背景3に変更" => ["scroll", -2, 1, [ 120, 0], true, "Sea_ex03", "Sea_ex02", true],
    "海背景4に変更" => ["scroll", -3, 1, [ 40, 0], true, "Sea_ex01", "Sea_ex04", true],
    "宇宙に変更1" => ["scroll", -4, 1, [ 0, 0], true, "DarkSpace", "", false],
    "宇宙に変更2" => ["scroll", -4, 2, [ 0, 0], true, "DarkSpace", "", false],

    #--------------------------------------------------------------------------
    # ● 周期ピクチャ 周期的にタイル状の クチャを操作します。風や巨大魔方 などに
    #--------------------------------------------------------------------------
    # スイッチ…実行合図となるゲーム イッチ番号
    # 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"],
    "魔方陣" => ["kpic", -5, 1, [ 0, 0], 0, [ 255, 0], 90, true, true, "magic_square01"],

    #--------------------------------------------------------------------------
    # ● 周期SE 周期的に効果音を鳴らします 。雷鳴や潮騒などに
    #--------------------------------------------------------------------------
    # スイッチ…実行合図となるゲーム イッチ番号
    # 周期…効果音を鳴らす周期。単位は1 レーム。この間隔で効果音が定期的 に鳴ります
    # ランダム幅…周期に加算されるラ ダム幅。単位は1フレーム
    #
    # ピッチ…ピッチ。50~150まで指定で きます。100がデフォルトです
    # 音量…ボリューム。50~150まで指定で きます。100がデフォルトです
    # 開始実行…プログラム実行直後 周期を待たず鳴らすならtrue
    # ファイル名…再生するファイル名。

    #――プログラム名―― 判別 スイッチ 周期 ランダム幅 ピッチ 音量 開始実行 ファイル名
    "カモメ" => ["keep_se", -1, 400, 100, 150, 60, false, "Crow"],
    "カモメ2" => ["keep_se", -1, 300, 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


    Спойлер 2:
    #================================================= =============================
    # ■ SideViewバトラー設定 Ver100
    #------------------------------------------------------------------------------
    #  アクション設定で作ったアクショ をバトラーに貼り付けたり
    #  バトラーに関する設定を行います
    #================================================= =============================
    class SideView
    #--------------------------------------------------------------------------
    # ● バトラーアニメ画像の横・縦セル数 = [ 横, 縦] アニメさせない場合は[1, 1]
    #--------------------------------------------------------------------------
    def max_pattern
    # バトラーIDで分岐
    case id
    when 1 # 1番のアクター
    return [ 3, 4]
    when -1 # 1番のエネミー(エネミーはIDをマイナ にすることで指定します)
    return [ 1, 1]
    else # 上のID以外を一括で設定
    return [ 3, 4] if id > 0 # 全アクター(IDがプラス)
    return [ 1, 1] if id < 0 # 全エネミー(IDがマイナス)
    end
    # 以降の設定でID分岐させる場合はこの 記述を参考にしてください
    end
    #--------------------------------------------------------------------------
    # ● 影画像ファイル名 画像はCharactersフォルダに入れてくだ い falseで影なし
    #--------------------------------------------------------------------------
    def shadow
    return "shadow01" if id > 0 # 全アクター
    return false if id < 0 # 全エネミー
    end
    #--------------------------------------------------------------------------
    # ● バトラー画像反転設定 初期状態で トラー画像を反転させるならtrue
    #--------------------------------------------------------------------------
    def graphic_mirror_flag
    return false if id > 0 # 全アクター
    return true if id < 0 # 全エネミー
    end
    #--------------------------------------------------------------------------
    # ● バトラー画像参照先固定 バトラ アニメ設定のインデックス参照を ず""にするならtrue
    #--------------------------------------------------------------------------
    def graphic_fix
    return false if id > 0 # 全アクター
    return true if id < 0 # 全エネミー
    end
    #--------------------------------------------------------------------------
    # ● 通常待機
    #--------------------------------------------------------------------------
    def normal
    return "通常待機" if id > 0 # 全アクター
    return "待機固定WT" if id < 0 # 全エネミー
    # フルアクションではなくアクション けを貼り付けることもできます
    end
    #--------------------------------------------------------------------------
    # ● ピンチ待機 HPが1/4以下の状態で行う待機アクション
    #--------------------------------------------------------------------------
    def pinch
    return "ピンチ待機" if id > 0 # 全アクター
    end
    #--------------------------------------------------------------------------
    # ● ステートアクション 複数重なった場合、表示優先度の高 ステートが優先されます
    #--------------------------------------------------------------------------
    def state(state_id)
    # ステートIDで分岐
    case state_id
    when 1
    return "戦闘不能" if id > 0 # 全アクター
    return "敵コラプス" if id < 0 # 全エネミー
    when 2
    return "毒待機"
    when 6
    return "睡眠待機"
    when 3,4,5,7,8
    return "汎用状態異常待機"
    when 9
    return "防御待機"
    end
    end
    #--------------------------------------------------------------------------
    # ● コマンド入力後のアクション
    #--------------------------------------------------------------------------
    def command
    # 選択したスキルIDで分岐
    case skill_id
    when 2
    return "コマンド後防御"
    end
    # 選択したスキルタイプで指定
    case skill_type
    when 1 # 特技
    return "コマンド後特技"
    when 2 # 魔法
    return "コマンド後魔法"
    end
    end
    #--------------------------------------------------------------------------
    # ● 戦闘開始アクション
    #--------------------------------------------------------------------------
    def first_action
    return "戦闘開始味方" if id > 0 # 全アクター
    return "待機固定WT" if id < 0 # 全エネミー
    end
    #--------------------------------------------------------------------------
    # ● 勝利アクション
    #--------------------------------------------------------------------------
    def win
    case id
    when 2,7,10 # 2・7・10番のアクター
    return "勝利ポーズバク転"
    else # 上記以外
    return "勝利ポーズ振り"
    end
    end
    #--------------------------------------------------------------------------
    # ● 戦闘退場アクション パーティの入れ替えが行われた際の 場アクション
    #--------------------------------------------------------------------------
    def remove_action
    return "味方退場"
    end
    #--------------------------------------------------------------------------
    # ● 逃走アクション
    #--------------------------------------------------------------------------
    def escape
    return "逃走" if id > 0 # 全アクター
    return "敵逃走" if id < 0 # 全エネミー
    end
    #--------------------------------------------------------------------------
    # ● 逃走失敗アクション
    #--------------------------------------------------------------------------
    def escape_ng
    return "逃走失敗"
    end
    #--------------------------------------------------------------------------
    # ● コマンド入力開始動作
    #--------------------------------------------------------------------------
    def command_b
    return "コマンド入力"
    end
    #--------------------------------------------------------------------------
    # ● コマンド入力終了動作
    #--------------------------------------------------------------------------
    def command_a
    return "コマンド入力終了"
    end
    #--------------------------------------------------------------------------
    # ● 被ダメージアクション 
    #--------------------------------------------------------------------------
    def damage(attacker)
    # 受けた攻撃がクリティカルの場合
    if critical?
    return "被ダメージ大"
    # 回復の場合
    elsif recovery?
    # アクションを取らせたくない時はretur nのみを記述します
    return
    end
    # 受けたスキルIDで分岐
    case damage_skill_id
    when 1 # スキル1番の場合
    return "被ダメージ"
    when 136 # 特定のスキルにダメージアクション 取らせたくない時はここでreturnのみ 記述します
    return
    end
    # 受けたアイテムIDで指定(回復の場合 既にアクションが決定されています)
    case damage_item_id
    when 1 # アイテム1番の場合
    return
    else
    # 上のアイテムID以外
    if damage_item_id != 0
    return
    end
    end
    # ダメージが0の場合 (強化・弱体化魔法や防御、エネミー 逃走など)
    if damage_zero?
    return
    end
    # 上の設定に当てはまらない場合
    return "被ダメージ"
    end
    #--------------------------------------------------------------------------
    # ● 回避動作 被ダメージアクションと同じ分岐が 能です
    #--------------------------------------------------------------------------
    def evasion(attacker)
    return "盾ガード" if shield? # 盾を装備している場合
    return "回避"
    end
    #--------------------------------------------------------------------------
    # ● 相手の攻撃ミス時の動作 被ダメージアクションと同じ分岐が 能です
    #--------------------------------------------------------------------------
    def miss(attacker)
    return "盾ガード" if shield? # 盾を装備している場合
    return "回避"
    end
    #--------------------------------------------------------------------------
    # ● 武器アクション 通常攻撃のアクションを装備武器で 定します
    # エネミーは下のエネミー武器設定で たせることができます
    #--------------------------------------------------------------------------
    def weapon_action
    # 武器IDで指定
    case weapon_id
    when 0 # 武器0番の場合(素手)
    return "通常攻撃"
    when 1 # 武器1番の場合
    return "斬り攻撃"
    end
    # 武器タイプで指定
    case weapon_type
    when 1 # 武器タイプ1番の場合
    return "斬り攻撃"
    when 4,5,7,8,9 # 複数まとめて指定する場合
    return "斬り攻撃"
    when 2
    return "拳攻撃"
    when 3
    return "突き攻撃"
    when 6
    return "弓攻撃"
    end
    end
    #--------------------------------------------------------------------------
    # ● エネミー右手武器 エネミーにも装備武器をID指定します
    #--------------------------------------------------------------------------
    def enemy_weapon1_id
    case id
    when -1 # 1番のエネミー(エネミーはIDをマイナ にすることで分岐させます)
    return 10 # 武器IDを指定。0番は素手扱いです
    else
    return 0
    end
    end
    #--------------------------------------------------------------------------
    # ● エネミー左手武器 エネミーにも二刀装備武器をID指定し ます
    #--------------------------------------------------------------------------
    def enemy_weapon2_id
    return 0
    end
    #--------------------------------------------------------------------------
    # ● エネミー盾 エネミーにも盾をID指定します 左手武器より優先されます
    #--------------------------------------------------------------------------
    def enemy_shield_id
    return 0
    end
    #--------------------------------------------------------------------------
    # ● 武器グラフィック指定 
    #--------------------------------------------------------------------------
    # 武器アクションのタイプ設定で [1:独自画像] [2:2003仕様]を選択した際の
    # 参照先の画像をここで指定します
    # return "001-Weapon01" ←対応する武器グラフィックのファ ル名を入れてください
    # 武器グラフィックはCharactersフォルダ 入れてください
    # 特定の武器を非表示にしたい場合は の画像を用意して、それを指定しま
    def weapon_graphic(weapon_id, weapon_type)
    # 武器IDで指定
    case weapon_id
    when 1 # 武器1番の画像ファイル名
    return ""
    end
    # 武器タイプで指定
    case weapon_type
    when 6 # 武器タイプ6番の画像ファイル名
    return "bow01"
    end
    end
    #--------------------------------------------------------------------------
    # ● 盾グラフィック指定 
    #--------------------------------------------------------------------------
    # 武器アクションのタイプ設定で [1:独自画像] [2:2003仕様]を選択し、さらに
    # 武器アクションの逆手設定をtrueにし 場合の参照先の盾画像をここで指定 します
    #
    # return "001-Shield01" ←対応する盾グラフィックのファイ 名を入れてください
    # 盾グラフィックはCharactersフォルダに れてください
    def shield_graphic(weapon_id, shield_type)
    # 防具IDで指定
    case shield_id
    when 41 # 防具41番(バックラー)の画像ファイル
    return ""
    end
    # 防具タイプで指定
    case shield_type
    when 5 # 防具タイプ5番(小型盾)の画像ファイ 名
    return ""
    end
    end

    #--------------------------------------------------------------------------
    # ● スキルアクション
    #--------------------------------------------------------------------------
    def skill_action
    # スキルIDで指定
    case skill_id
    when 1 # スキル1番は通常攻撃なので、上の武 アクションを実行します
    return weapon_action
    when 2 # スキル2番は防御
    return "防御"
    when 3,4,5 # スキル3/4/5番は連続攻撃
    return weapon_action
    when 6 # スキル6番はエネミー逃走
    return escape
    when 7 # スキル7番は様子を見る
    return "様子見"
    when 128
    return "水鉄砲"
    when 129
    return "武器投げ"
    when 130
    return "5回攻撃"
    when 131
    return "カットイン攻撃"
    when 132
    return "ムービー攻撃"
    when 133
    return "オオカミ変身"
    when 134
    return "スキル派生"
    when 135
    return "暗転攻撃"
    when 136
    return "空中攻撃"
    end
    # スキル名で指定(データベースでIDを 動させても大丈夫なのでお勧めです)
    case skill_name
    when "背景変更サンプル"
    return "背景変更攻撃"
    when "ピクチャ攻撃サンプル"
    return "ピクチャ攻撃"
    end
    # スキルタイプで指定
    case skill_type
    when 1 # 特技
    return "汎用スキル"
    when 2 # 魔法
    return "汎用魔法"
    end
    # 上記以外
    return "汎用スキル"
    end
    #--------------------------------------------------------------------------
    # ● アイテムアクション
    #--------------------------------------------------------------------------
    def item_action
    case item_id # アイテムIDで指定
    when 1
    return "アイテム使用"
    else
    return "アイテム使用"
    end
    end
    #--------------------------------------------------------------------------
    # ● カウンタースキルID カウンター時の スキルIDを指定します
    #--------------------------------------------------------------------------
    # ※データベースで設定された複数回 撃は反映されません
    def counter_skill_id
    return 1
    end
    #--------------------------------------------------------------------------
    # ● 魔法反射アニメID 魔法反射時のアニ メIDを指定します
    #--------------------------------------------------------------------------
    def reflection_anime_id
    return 118
    end
    #--------------------------------------------------------------------------
    # ● 身代わり開始アクション
    #--------------------------------------------------------------------------
    def substitute_start_action
    return "身代わり開始"
    end
    #--------------------------------------------------------------------------
    # ● 身代わり終了アクション
    #--------------------------------------------------------------------------
    def substitute_end_action
    return "身代わり終了"
    end
    #--------------------------------------------------------------------------
    # ● 身代わりされた側のアクション開始
    #--------------------------------------------------------------------------
    def substitute_receiver_start_action
    return "被身代わり開始"
    end
    #--------------------------------------------------------------------------
    # ● 身代わりされた側のアクション終了
    #--------------------------------------------------------------------------
    def substitute_receiver_end_action
    return "被身代わり終了"
    end
    #--------------------------------------------------------------------------
    # ● エネミーのレベル 条件分岐などに利用するためのもの 、パラメータは反映されません
    #--------------------------------------------------------------------------
    def level
    case id
    when -1 # 1番のエネミー
    return 0
    end
    return 0
    end

    end




    Проблема решена , подставил аргументы
    when 3,4,5 # スキル3/4/5番は連続攻撃
    return weapon_action

    в нужные спелы и все ок )
    Последний раз редактировалось rammsteks; 12.02.2013 в 09:19.

  10. #850
    Местный Аватар для ReDS
    Информация о пользователе
    Регистрация
    26.07.2009
    Адрес
    Петропавловск-Камчатский
    Сообщений
    127
    Записей в дневнике
    1
    Репутация: 23 Добавить или отнять репутацию

    По умолчанию

    Цитата Сообщение от SethNsk Посмотреть сообщение
    Подскажите, как использовать данный скрипт?
    Спойлер скрипт:
    PHP код:
    # 9Sun - Event Spawner Fix
    #
    # Please note that the spawn_event function doesn't belong to me. I forget where I found it. Contact me if you created
    # this snippet so that I can put your name as credit.
    #
    # Event Spawner
    #   _map_id:   ID of the map where the events resides
    #   _event_id: The Event ID
    #   _x:        X Coordinate the put the new event
    #   _y:        Y Coordinate the put the new event
    #
    #   Returns: New Event ID
    #

    # Some fixes done on this function (I didn't wrote the original piece).

    def spawn_event(_map_id_event_id_x_y)
      
    map              load_data(sprintf("Data/Map%03d.rvdata2"_map_id))
      
    event_id         $game_map.events.keys.max 1
      event            
    $game_map.events[event_id] = Game_Event.new($game_map.map_idmap.events[_event_id],event_id)
      
    event.moveto(_x_y)
      
    sp_map           SceneManager.scene.instance_eval('@spriteset')
      
    sp_map_char_sprs sp_map.instance_eval('@character_sprites')
      
    sp_map_view_1    sp_map.instance_eval('@viewport1')
      
    sp_map_char_sprs.push(Sprite_Character.new(sp_map_view_1event))
      
    event_id
    end

    # Following are the fix written by me. It overwrites alot of methods in Game_Event class so check yourself for compatibility issues.

    class Game_Event Game_Character
      def initialize
    (map_ideventreal_id false)
        
    super()
        @
    map_id map_id
        
    @event event
        
    @real_id real_id real_id : @event.id
        
    @id = @real_id
        moveto
    (@event.x, @event.y)
        
    refresh
      end

      def conditions_met
    ?(page)
        
    page.condition
        
    if c.switch1_valid
          
    return false unless $game_switches[c.switch1_id]
        
    end
        
    if c.switch2_valid
          
    return false unless $game_switches[c.switch2_id]
        
    end
        
    if c.variable_valid
          
    return false if $game_variables[c.variable_id] < c.variable_value
        end
        
    if c.self_switch_valid
          key 
    = [@map_id, @real_idc.self_switch_ch]
          return 
    false if $game_self_switches[key] != true
        end
        
    if c.item_valid
          item 
    $data_items[c.item_id]
          return 
    false unless $game_party.has_item?(item)
        
    end
        
    if c.actor_valid
          actor 
    $game_actors[c.actor_id]
          return 
    false unless $game_party.members.include?(actor)
        
    end
        
    return true
      end

      alias sun_event_spawn_erase erase

      def erase
        
    if @event.id != @real_id
          
    ['A','B','C','D'].each{|ch|
            
    key = [@map_id, @real_idch]
            
    $game_self_switches[key] = false
            
    }
        
    end
        sun_event_spawn_erase
      end

      def update
        super
        check_event_trigger_auto
        
    return unless @interpreter
        
    @interpreter.setup(@list, @real_idunless @interpreter.running?
        @
    interpreter.update
      end
    end 
    А может кто этот скрипт под XP переделать?
    Цитата Сообщение от Antberg Посмотреть сообщение
    Кто-нибудь знает, как на ХР сделать так, что-бы кнопка Enter была равнозначна кнопке Z? Пробовал везде в скриптах заменить "Input::C" на "Input::A" ("A" в ХР означает "Z"), но таким образом удалось просто назначить функцию "решение" на кнопку "Z", в то время как Enter перестал работать. И похоже, работает он только с кнопкой "С". Может, как-то всё-же эта проблема решается?
    По-моему, простой правкой стандартных скриптов такое не сделать. Назначить Enter-у значение кнопки "А" можно только в настройках rgss плеера (F1) или как-нибудь через сторонний скрипт, например Glitchfinder's Key Input Module.

    "Главное не суть идеи, а её реализация." (с)

Страница 85 из 143 ПерваяПервая ... 3575838485868795135 ... ПоследняяПоследняя

Информация о теме

Пользователи, просматривающие эту тему

Эту тему просматривают: 1 (пользователей: 0 , гостей: 1)

Метки этой темы

Социальные закладки

Социальные закладки

Ваши права

  • Вы не можете создавать новые темы
  • Вы не можете отвечать в темах
  • Вы не можете прикреплять вложения
  • Вы не можете редактировать свои сообщения
  •