请教一下这段脚本的意义,好么?

wuoismiao

# 味方はキャラクター名、エネミーはバトラー名を取得
     @battler_name = @battler.character_name if @battler.actor?
     @battler_name = @battler.battler_name unless @battler.actor?
     # エネミー反転がオンの場合、画像を反転させる
     self.mirror = true if [email protected]? && @battler.action_mirror
     # 歩行グラフィックを利用するかどうかで転送元の矩形サイズの認識先を変える
     self.bitmap = Cache.character(@battler_name) if N01::WALK_ANIME
     self.bitmap = Cache.character(@battler_name + "_1") unless N01::WALK_ANIME
上面这段脚本是什么意思呢?每一句指令都能起到什么作用呢?想请教一下各位,真的很感谢!

火鸡三毛老大

取得步行图？      应该是这样....

wuoismiao

其实,这个是从公主越狱记的横版战斗相关里拿出来的

那么,决定角色战斗图的脚本段究竟在哪里呢?

再次 谢谢!

火鸡三毛老大

请把 脚本贴出来

enghao_lim

难怪看了这么熟悉，这是Sideview（菜鸟级横板战斗）的脚本吧。

以下引用wuoismiao于2008-3-21 20:39:13的发言：
其实,这个是从公主越狱记的横版战斗相关里拿出来的
那么,决定角色战斗图的脚本段究竟在哪里呢?
再次 谢谢!

公主越狱记没看过，不过这整个def make_battler就是生成角色战斗图的脚本。

  def make_battler
    # 初期配置の取得
    @battler.base_position
    # 色相はバトラーとして認識
    @battler_hue = @battler.battler_hue
    # バトラーがアクターの場合、またはエネミーアニメがオンの場合
    if @anime_flug
      # メイン武器を用意
      @weapon_R = Sprite_Weapon.new(viewport,@battler)
      # 味方はキャラクター名、エネミーはバトラー名を取得
      @battler_name = @battler.character_name if @battler.actor?
      @battler_name = @battler.battler_name unless @battler.actor?
      # エネミー反転がオンの場合、画像を反転させる
      self.mirror = true if [email protected]? && @battler.action_mirror
      # 歩行グラフィックを利用するかどうかで転送元の矩形サイズの認識先を変える
      self.bitmap = Cache.character(@battler_name) if N01::WALK_ANIME
      self.bitmap = Cache.character(@battler_name + "_1") unless N01::WALK_ANIME
      # 転送元の矩形を取得
      @width = self.bitmap.width / @base_width
      @height = self.bitmap.height / @base_height
      # 矩形を設定
      @sx = @pattern * @width
      @sy = @anime_kind * @height
      # バトラー本体を描画
      self.src_rect.set(@sx, @sy, @width, @height)
    # アニメしないバトラーの場合
    else
      # ビットマップを取得、設定
      @battler_name = @battler.battler_name
      self.bitmap = Cache.battler(@battler_name, @battler_hue)
      @width = bitmap.width
      @height = bitmap.height
    end
    # バックアタック時には画像を反転させる
    self.mirror = false if self.mirror && $back_attack && N01::BACK_ATTACK
    self.mirror = true if $back_attack && !self.mirror && N01::BACK_ATTACK
    # 位置を初期化
    @battler.reset_coordinate
    # 原点を決定
    self.ox = @width / 2
    self.oy = @height * 2 / 3
    # スプライトの座標を設定
    update_move
    # アニメ飛ばし用スプライトを用意
    @move_anime = Sprite_MoveAnime.new(viewport,battler)
    # ピクチャ用スプライトを用意
    @picture = Sprite.new
    # 影スプライトを用意
    make_shadow if N01::SHADOW
    # ダメージスプライト作成
    @damage = Sprite_Damage.new(viewport,battler)
  end

wuoismiao

全本如下..麻烦帮我解释下好么?

#==============================================================================
# ■ Sprite_Battler Ver1.5
#------------------------------------------------------------------------------
# 　バトラー表示用のスプライトです。
#==============================================================================
class Sprite_Battler < Sprite_Base
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(viewport, battler = nil)
    super(viewport)
    @battler = battler
    @battler_visible = false
    @effect_type = 0                   # エフェクトの種類
    @effect_duration = 0               # エフェクトの残り時間
    @move_x = 0                        # 変化したX座標の累計
    @move_y = 0                        # 変化したY座標の累計
    @move_z = 0                        # 変化したZ座標の累計
    @distanse_x = 0                    # X座標の移動距離
    @distanse_y = 0                    # Y座標の移動距離
    @moving_x = 0                      #１フレームあたりのX座標移動距離
    @moving_y = 0                      #１フレームあたりのY座標移動距離
    @move_speed_x = 0                  # X座標の移動速度
    @move_speed_y = 0                  # Y座標の移動速度
    @move_speed_plus_x = 0             # X座標の加減速時の補足移動速度
    @move_speed_plus_y = 0             # Y座標の加減速時の補足移動速度
    @move_boost_x = 0                  # X座標加速度
    @move_boost_y = 0                  # Y座標加速度
    @jump_time = 0                     # ジャンプ時間
    @jump_time_plus = 0                # ジャンプ時間補足
    @jump_up = 0                       # ジャンプ上昇
    @jump_down = 0                     # ジャンプ下降
    @jump_size = 0                     # ジャンプ高度
    @float_time = 0                    # 浮遊時間
    @float_up = 0                      # １フレームあたりの浮遊高度
    @jump_plus = 0                     # ジャンプに対する影位置補正
    @angle = 0                         # 回転角度
    @angling = 0                       # １フレームあたりの回転角度
    @angle_time = 0                    # 回転時間
    @angle_reset = 0                   # 角度をリセットするか
    @zoom_x = 0                        # 横の拡大率
    @zoom_y = 0                        # 縦の拡大率
    @zooming_x = 0                     # １フレームあたりの横拡大率
    @zooming_y = 0                     # １フレームあたりの縦拡大率
    @zoom_time = 0                     # 拡大時間
    @zoom_reset = 0                    # 拡大をリセットするか
    @target_battler = []               # ターゲットバトラー情報
    @now_targets = []                  # ターゲットバトラー記憶
    @pattern = 0                       # セル横位置（更新位置）
    @pattern_back = false              # リピートフラグ
    @wait = 0                          # 次の動作待ち時間
    @unloop_wait = 0                   # 非ループ系アニメ終了時の待ち時間
    @action = []                       # 行動
    @anime_kind = 0                    # セル縦位置（アニメ種類位置）
    @anime_speed = 0                   # セル更新速度
    @frame = 0                         # 消費されるセル更新時間
    @anime_loop = 0                    # ループ方式
    @anime_end = false                 # バトラーのアニメが終わったか
    @anime_freeze = false              # 固定アニメか
    @anime_freeze_kind = false         # 固定するパターン位置
    @anime_moving = false              # 飛ばしアニメ中か
    @base_width = N01::ANIME_PATTERN   # セルの横分割数
    @base_height = N01::ANIME_KIND     # セルの縦分割数
    @width = 0                         # 横矩形
    @height = 0                        # 縦矩形
    @picture_time = 0                  # ピクチャー表示時間
    @individual_targets = []           # 個別処理の保持ターゲット
    @balloon_duration = 65             # ふきだしアニメ時間
    # バトラーがいない場合は処理を中断
    return @battler_visible = false if @battler == nil
    # バトラーがアクターの場合、またはエネミーアニメがオンの場合
    @anime_flug = true if @battler.actor?
    @anime_flug = true if [email protected]? && @battler.anime_on
    # バトラー作成
    make_battler
  end
  #--------------------------------------------------------------------------
  # ● バトラー作成
  #--------------------------------------------------------------------------
  def make_battler
    # 初期配置の取得
    @battler.base_position
    # 色相はバトラーとして認識
    @battler_hue = @battler.battler_hue
    # バトラーがアクターの場合、またはエネミーアニメがオンの場合
    if @anime_flug
      # メイン武器を用意
      @weapon_R = Sprite_Weapon.new(viewport,@battler)
      # 味方はキャラクター名、エネミーはバトラー名を取得
      @battler_name = @battler.character_name if @battler.actor?
      @battler_name = @battler.battler_name unless @battler.actor?
      # エネミー反転がオンの場合、画像を反転させる
      self.mirror = true if [email protected]? && @battler.action_mirror
      # 歩行グラフィックを利用するかどうかで転送元の矩形サイズの認識先を変える
      self.bitmap = Cache.character(@battler_name) if N01::WALK_ANIME
      self.bitmap = Cache.character(@battler_name + "_1") unless N01::WALK_ANIME
      # 転送元の矩形を取得
      @width = self.bitmap.width / @base_width
      @height = self.bitmap.height / @base_height
      # 矩形を設定
      @sx = @pattern * @width
      @sy = @anime_kind * @height
      # バトラー本体を描画
      self.src_rect.set(@sx, @sy, @width, @height)
    # アニメしないバトラーの場合
    else
      # ビットマップを取得、設定
      @battler_name = @battler.battler_name
      self.bitmap = Cache.battler(@battler_name, @battler_hue)
      @width = bitmap.width
      @height = bitmap.height
    end
    # バックアタック時には画像を反転させる
    self.mirror = false if self.mirror && $back_attack && N01::BACK_ATTACK
    self.mirror = true if $back_attack && !self.mirror && N01::BACK_ATTACK
    # 位置を初期化
    @battler.reset_coordinate
    # 原点を決定
    self.ox = @width / 2
    self.oy = @height * 2 / 3
    # スプライトの座標を設定
    update_move
    # アニメ飛ばし用スプライトを用意
    @move_anime = Sprite_MoveAnime.new(viewport,battler)
    # ピクチャ用スプライトを用意
    @picture = Sprite.new
    # 影スプライトを用意
    make_shadow if N01::SHADOW
    # ダメージスプライト作成
    @damage = Sprite_Damage.new(viewport,battler)
  end
  #--------------------------------------------------------------------------
  # ● 影作成
  #--------------------------------------------------------------------------
  def make_shadow
    @shadow.dispose if @shadow != nil
    @battler_hue = @battler.battler_hue
    @shadow = Sprite.new(viewport)
    @shadow.z = 200
    @shadow.visible = false
    # バトラーに当てられた影グラフィックを用意
    @shadow.bitmap = Cache.character(@battler.shadow)
    @shadow_height = @shadow.bitmap.height
    # 影位置の微調整用インスタンス
    @shadow_plus_x = @battler.shadow_plus[0] - @width / 2
    @shadow_plus_y = @battler.shadow_plus[1]
    # バトラー画像のサイズに合わせて影画像をリサイズ
    @shadow.zoom_x = @width * 1.0 / @shadow.bitmap.width
    # 更新
    update_shadow
    # フェードに影が引っかからないようにフラグを立てる
    @skip_shadow = true
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  def dispose
    self.bitmap.dispose if self.bitmap != nil
    @weapon_R.dispose if @weapon_R != nil
    @move_anime.dispose if @move_anime != nil
    @picture.dispose if @picture != nil
    @shadow.dispose if @shadow != nil
    @damage.dispose if @damage != nil
    @balloon.dispose if @balloon != nil
    mirage_off
    super
  end  
  #--------------------------------------------------------------------------
  # ● ダメージアクション  action = [アニメID,反転フラグ,リアクション許可]
  #--------------------------------------------------------------------------
  def damage_action(action)
    damage = @battler.hp_damage
    damage = @battler.mp_damage if @battler.mp_damage != 0
    # ヒットしている時のみアニメ実行
    unless @battler.evaded or @battler.missed or action[0] == nil
      @battler.animation_id = action[0]
      @battler.animation_mirror = action[1]
    end
    # ダメージアクション実行
    start_action(@battler.damage_hit) if damage > 0 && action[2]
    # 攻撃が当たっていない場合は回避アクション実行
    if @battler.evaded or @battler.missed
      start_action(@battler.evasion) if action[2]
      Sound.play_evasion
    end
    @damage.damage_pop
  end
  #--------------------------------------------------------------------------
  # ● ダメージ数値POP
  #--------------------------------------------------------------------------
  def damage_pop(damage)
    @damage.damage_pop(damage)
  end  
  #--------------------------------------------------------------------------
  # ● 戦闘開始行動
  #--------------------------------------------------------------------------
  def first_action
    # 行動できるかチェックし、できなければそのステートのアクション開始
    action = @battler.first_action unless @battler.restriction == 4
    action = $data_states[@battler.state_id].base_action if @battler.states[0] != nil && @battler.restriction == 4
    start_action(action)
    @skip_shadow = false
  end
  #--------------------------------------------------------------------------
  # ● アクション開始
  #--------------------------------------------------------------------------
  def start_action(kind)
    # 各種動作を初期化
    reset
    # 現在取っている待機アクションを記憶
    stand_by
    # 新しいアクション内容の決定
    @action = N01::ACTION[kind].dup
    # 行動配列の先頭からシフト
    active = @action.shift
    # 自動で終了を付ける
    @action.push("終了")
    # 現在のアクションを決定
    @active_action = N01::ANIME[active]
    # ウエイト設定
    @wait = active.to_i if @active_action == nil
    # 単発アクション開始
    action
  end
  #--------------------------------------------------------------------------
  # ● 強制単発アクション開始
  #--------------------------------------------------------------------------
  def start_one_action(kind,back)
    # 各種動作を初期化
    reset
    # 現在取っている待機アクションを記憶
    stand_by
    # 座標リセットアクションをセッティング
    @action = [back]
    # 自動で終了を付ける
    @action.push("終了")
    # 現在のアクションを決定
    @active_action = N01::ANIME[kind]
    # 単発アクション開始
    action
  end
  #--------------------------------------------------------------------------
  # ● 次のアクションへ
  #--------------------------------------------------------------------------
  def next_action
    # ウェイト中の場合キャンセル
    return @wait -= 1 if @wait > 0
    # まだ全アニメセルが終了していない場合キャンセル
    return if @anime_end == false
    # 最後のアニメセル表示待ち
    return @unloop_wait -= 1 if @unloop_wait > 0
    # 行動配列の先頭からシフト
    active = @action.shift
    # 現在のアクションを決定
    @active_action = N01::ANIME[active]
    # ウエイト設定
    @wait = active.to_i if @active_action == nil
    # 単発アクション開始
    action
  end
  #--------------------------------------------------------------------------
  # ● 待機アクション
  #--------------------------------------------------------------------------
  def stand_by
    # 通常待機に
    @repeat_action = @battler.normal
    # HPが1/4でピンチモーションに
    @repeat_action = @battler.pinch if @battler.hp <= @battler.maxhp / 4
    # 防御中
    @repeat_action = @battler.defence if @battler.guarding?
    # 何もステートがなければ終了
    return if @battler.state_id == nil
    for state in @battler.states.reverse
      # アクション禁止のステートだったらスキップ
      next if $data_states[state.id].extension.include?("ステートアクション禁止")
      # エネミーで禁止されているステートアクションだったらスキップ
      next if @battler.is_a?(Game_Enemy) && $data_states[state.id].extension.include?("エネミー除外")
      # ステートのモーションに
      @repeat_action = $data_states[state.id].base_action
    end
  end
  #--------------------------------------------------------------------------
  # ● 待機アクションの割り込み
  #--------------------------------------------------------------------------
  def push_stand_by
    action = @battler.normal
    action = @battler.pinch if @battler.hp <= @battler.maxhp / 4
    action = @battler.defence if @battler.guarding?
    for state in @battler.states.reverse
      # アクション禁止のステートだったらスキップ
      next if $data_states[state.id].extension.include?("ステートアクション禁止")
      # エネミーで禁止されているステートアクションだったらスキップ
      next if @battler.is_a?(Game_Enemy) && $data_states[state.id].extension.include?("エネミー除外")
      # ステートのモーションに
      action = $data_states[state.id].base_action
    end
    @repeat_action = action
    # 割り込み
    @action.delete("終了")
    act = N01::ACTION[action].dup
    for i in 0...act.size
      @action.push(act)
    end  
    @action.push("終了")
  end
  #--------------------------------------------------------------------------
  # ● 各種変化を初期化
  #--------------------------------------------------------------------------
  def reset
    self.zoom_x = self.zoom_y = 1
    self.oy = @height * 2 / 3
    @angle = self.angle = 0
    @anime_end = true
    @non_repeat = false
    @anime_freeze = false
    @unloop_wait = 0
  end  
  #--------------------------------------------------------------------------
  # ● ジャンプを初期化
  #--------------------------------------------------------------------------
  def jump_reset
    @battler.jump = @jump_time = @jump_time_plus = @jump_up = @jump_down = 0
    @jump_size = @jump_plus = @float_time = @float_up = 0
  end
  #--------------------------------------------------------------------------
  # ● ターゲット情報を受け取る
  #--------------------------------------------------------------------------
  def get_target(target)
    # 個別処理中は中止(全域で自分が巻き込まれた時ターゲット情報が狂わないように)
    return if @battler.individual
    @target_battler = target
  end
  #--------------------------------------------------------------------------
  # ● アクション情報をバトラーに格納
  #--------------------------------------------------------------------------
  def send_action(action)
    @battler.play = 0
    @battler.play = action if @battler.active
  end
  #--------------------------------------------------------------------------
  # ● バトラー追加
  #--------------------------------------------------------------------------
  def battler_join
    if @battler.exist? && !@battler_visible
      # 戦闘不能からの復活なら処理をスキップ
      if @battler.revival && @anime_flug
        return @battler.revival = false
      elsif @battler.revival && !@anime_flug
        @battler.revival = false
        self.visible = true
        return
      end  
      @anime_flug = true if @battler.actor?
      @anime_flug = true if [email protected]? && @battler.anime_on
      make_battler
      @damage = Sprite_Damage.new(viewport,battler)
      @join = true
      first_action
    end
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新　※再定義
  #--------------------------------------------------------------------------
  def update
    super
    # バトラーがいない場合スキップ
    return self.bitmap = nil if @battler == nil
    # バトラー追加
    battler_join
    # 次のアクションへ
    next_action
    # アニメパターン更新
    update_anime_pattern
    # ターゲット更新
    update_target
    # 強制アクション更新
    update_force_action
    # 座標更新
    update_move
    # 影更新
    update_shadow if @shadow != nil
    # 武器更新
    @weapon_R.update if @weapon_action
    # 浮遊更新
    update_float if @float_time > 0
    # 回転更新
    update_angle if @angle_time > 0
    # 拡大縮小更新
    update_zoom if @zoom_time > 0
    # 残像更新
    update_mirage if @mirage_flug
    # ピクチャ更新
    update_picture if @picture_time > 0
    # アニメ飛ばし更新
    update_move_anime if @anime_moving
    # ふきだしアニメ更新
    update_balloon if @balloon_duration <= 64
    # ダメージスプライト更新
    @damage.update
    setup_new_effect
    update_effect
    update_battler_bitmap
  end

wuoismiao

#--------------------------------------------------------------------------
  # ● アニメパターン更新
  #--------------------------------------------------------------------------
  def update_anime_pattern
    # 更新時間がくるまでスキップ
    return @frame -= 1 if @frame != 0
    # 必要な時だけ武器アニメ更新
    @weapon_R.action if @weapon_action && @weapon_R != nil
    # アニメのコマが最後まで到達したらリピート方法をチェック
    if @pattern_back
      # 往復ループ
      if @anime_loop == 0
        @pattern -= 1
        @pattern_back = false if @pattern == 0
        @anime_end = true if @pattern == 0
      # 片道ループもしくはループしない
      else
        @anime_end = true
        @pattern = 0 if @anime_loop == 1
        @pattern_back = false if @anime_loop == 1
      end  
    # アニメのコマを進める   
    else
      @pattern += 1
      @pattern_back = true if @pattern == @base_width - 1
    end
    # 更新時間を初期化
    @frame = @anime_speed
    # アニメ固定の場合は横矩形を固定
    return if @anime_freeze
    # 転送元の矩形を設定
    return unless @anime_flug
    @sx = @pattern * @width
    @sy = @anime_kind * @height
    self.src_rect.set(@sx, @sy, @width, @height)
  end
  #--------------------------------------------------------------------------
  # ● ターゲット更新 action = ["N01target_change",ターゲット情報]
  #--------------------------------------------------------------------------
  def update_target
    # ターゲットチェック
    return if @battler.force_target == 0
    # 個別処理中は中止(全域で自分が巻き込まれた時ターゲット情報が狂わないように)
    return if @battler.individual
    @target_battler = @battler.force_target[1]
    @battler.force_target = 0
  end  
  #--------------------------------------------------------------------------
  # ● 強制アクション更新 action = [識別,復帰,実行するアクション]
  #--------------------------------------------------------------------------
  def update_force_action
    # 強制アクションチェック
    action = @battler.force_action
    return if action == 0
    @battler.force_action = 0
    # アクティブ中は割り込ませない
    return if @battler.active
    # コラプスならそのまま行動に直結
    return collapse_action if action[0] == "N01collapse"
    # 単発ならそのまま行動に直結
    return start_one_action(action[2],action[1]) if action[0] == "単発"
    # 通しはアクションとして扱う
    start_action(action[2])
    # 座標復帰の有無
    return if action[1] == ""
    # 終了位置を入れ替えて復帰アクションを入れる
    @action.delete("終了")
    @action.push(action[1])
    @action.push("終了")
  end   
  #--------------------------------------------------------------------------
  # ● 座標更新
  #--------------------------------------------------------------------------
  def update_move
    # 加減速で出る距離の増減を補完
    if @move_speed_plus_x > 0
      # 移動計算
      @move_x += @moving_x
      # 移動を実行
      @battler.move_x = @move_x
      @move_speed_plus_x -= 1
    elsif @move_speed_x > 0
      # 加速の場合
      if @move_boost_x != 0
        @moving_x += @move_boost_x
      end  
      # 移動計算
      @move_x += @moving_x
      # 移動を実行
      @battler.move_x = @move_x
      @move_speed_x -= 1
    end
    # 加減速で出る距離の増減を補完
    if @move_speed_plus_y > 0
      # 移動計算
      @move_y += @moving_y
      # 移動を実行
      @battler.move_y = @move_y
      @move_speed_plus_y -= 1
    elsif @move_speed_y > 0
      # 加速の場合
      if @move_boost_y != 0
        @moving_y += @move_boost_y
      end  
      # 移動計算
      @move_y += @moving_y
      # 移動を実行
      @battler.move_y = @move_y
      @move_speed_y -= 1
    end
    # ジャンプ上昇
    if @jump_up != 0
      # 移動計算
      @jump_plus += @jump_up
      # 移動を実行
      @battler.jump = @jump_plus
      @jump_up = @jump_up / 2
      @jump_time -= 1
      # ジャンプが頂点に達したら
      if @jump_time == 0 or @jump_up == @jump_sign
        @jump_down = @jump_up * 2 * @jump_sign * @jump_sign2
        @jump_time_plus += @jump_time * 2
        @jump_up = 0
        return
      end  
    end  
    # ジャンプ下降
    if @jump_down != 0
      if @jump_time_plus != 0
        @jump_time_plus -= 1
      elsif @jump_down != @jump_size
        # 移動計算
        @jump_plus += @jump_down
        # 移動を実行
        @battler.jump = @jump_plus
        @jump_down = @jump_down * 2
        if @jump_down == @jump_size
          if @jump_flug
            @jump_flug = false
          else
            # 移動計算
            @jump_plus += @jump_down
            # 移動を実行
            @battler.jump = @jump_plus
            @jump_down = @jump_size = 0
          end
        end  
      end
    end
    # スプライトの座標を設定
    self.x = @battler.position_x
    self.y = @battler.position_y
    self.z = @battler.position_z
  end
  #--------------------------------------------------------------------------
  # ● 影更新
  #--------------------------------------------------------------------------
  def update_shadow
    @shadow.opacity = self.opacity
    @shadow.x = self.x + @shadow_plus_x
    @shadow.y = self.y + @shadow_plus_y - @jump_plus
  end
  #--------------------------------------------------------------------------
  # ● 浮遊更新
  #--------------------------------------------------------------------------
  def update_float
    @float_time -= 1
    @jump_plus += @float_up
    @battler.jump = @jump_plus
  end   
  #--------------------------------------------------------------------------
  # ● 回転更新
  #--------------------------------------------------------------------------
  def update_angle
    # 回転実行
    @angle += @angling
    self.angle = @angle
    @angle_time -= 1
    # 回転時間がなくなったら項目をリセット
    return @angle = 0 if @angle_time == 0
    # 復帰フラグがあれば角度を0に戻す
    self.angle = 0 if @angle_reset
  end  
  #--------------------------------------------------------------------------
  # ● 拡大縮小更新
  #--------------------------------------------------------------------------
  def update_zoom
    # 拡大縮小実行
    @zoom_x += @zooming_x
    @zoom_y += @zooming_y
    self.zoom_x = @zoom_x
    self.zoom_y = @zoom_y
    @zoom_time -= 1
    # 拡大縮小時間がなくなったら項目をリセット
    return if @zoom_time != 0
    @zoom_x = @zoom_y = 0
    self.oy = @height * 2 / 3
    # 復帰フラグがあれば戻す
    self.zoom_x = self.zoom_y = 1 if @zoom_reset
  end  
  #--------------------------------------------------------------------------
  # ● 残像更新
  #--------------------------------------------------------------------------
  def update_mirage
    # 残像は最大3つまで表示し、２フレームごとに更新
    mirage(@mirage0) if @mirage_count == 1
    mirage(@mirage1) if @mirage_count == 3
    mirage(@mirage2) if @mirage_count == 5
    @mirage_count += 1
    @mirage_count = 0 if @mirage_count == 6
  end
  #--------------------------------------------------------------------------
  # ● ピクチャ更新
  #--------------------------------------------------------------------------
  def update_picture
    @picture_time -= 1
    @picture.x += @moving_pic_x
    @picture.y += @moving_pic_y
  end  
  #--------------------------------------------------------------------------
  # ● アニメ飛ばし更新
  #--------------------------------------------------------------------------
  def update_move_anime
    @move_anime.update
    @anime_moving = false if @move_anime.finish?
    @move_anime.action_reset if @move_anime.finish?
  end  
  #--------------------------------------------------------------------------
  # ● 崩壊エフェクトの更新　※再定義
  #--------------------------------------------------------------------------
  def update_collapse
    normal_collapse if @collapse_type == 2
    boss_collapse1 if @collapse_type == 3
  end
  #--------------------------------------------------------------------------
  # ● ふきだしアニメ更新
  #--------------------------------------------------------------------------
  def update_balloon
    @balloon_duration -= 1 if @balloon_duration > 0 && !@balloon_back
    @balloon_duration += 1 if @balloon_back
    if @balloon_duration == 64
      @balloon_back = false
      @balloon.visible = false
    elsif @balloon_duration == 0
      @balloon.visible = false if @balloon_loop == 0
      @balloon_back = true if @balloon_loop == 1
    end   
    @balloon.x = self.x - @width / 5
    @balloon.y = self.y - @balloon_height
    @balloon.z = 10
    @balloon.opacity = self.opacity
    sx = 7 * 32 if @balloon_duration < 12
    sx = (7 - (@balloon_duration - 12) / 8) * 32 unless @balloon_duration < 12
    @balloon.src_rect.set(sx, @balloon_id * 32, 32, 32)
  end
  #--------------------------------------------------------------------------
  # ● 転送元ビットマップの更新 ※再定義
  #--------------------------------------------------------------------------
  def update_battler_bitmap
    return @battler.actor?
    if @battler.battler_name != @battler_name or @battler.battler_hue != @battler_hue
      @battler_name = @battler.battler_name
      @battler_hue = @battler.battler_hue
      make_battler
      self.opacity = 0 if @battler.dead? or @battler.hidden
    end
  end
  #--------------------------------------------------------------------------
  # ● アクション実行
  #--------------------------------------------------------------------------
  def action
    return if @active_action == nil
    action = @active_action[0]
    # 反転の場合
    return mirroring if action == "反転"
    # 回転の場合  
    return angling if action == "angle"
    # 拡大縮小の場合  
    return zooming if action == "zoom"
    # 残像ONの場合
    return mirage_on if action == "残像ON"
    # 残像OFFの場合
    return mirage_off if action == "残像OFF"
    # ピクチャ表示の場合
    return picture if action == "pic"
    # ピクチャ消去の場合
    return @picture.visible = false && @picture_time = 0 if action == "ピクチャ消去"
    # グラフィックファイル変更の場合  
    return graphics_change if action == "change"
    # 戦闘アニメ表示の場合  
    return battle_anime if action == "anime"
    # ふきだしアニメ表示の場合  
    return balloon_anime if action == "balloon"
    # BGM/BGS/SE演奏の場合  
    return sound if action == "sound"
    # ゲームスイッチ操作の場合  
    return $game_switches[@active_action[1]] = @active_action[2] if action == "switch"
    # ゲーム変数操作の場合  
    return variable if action == "variable"
    # 二刀限定の場合
    return two_swords if action == "二刀限定"
    # 非二刀限定の場合
    return non_two_swords if action == "非二刀限定"
    # アクション条件の場合
    return necessary if action == "nece"
    # スキル派生の場合  
    return derivating if action == "der"
    # 個別処理開始の場合
    return individual_action if action == "個別処理開始"
    # 個別処理終了の場合
    return individual_action_end if action == "個別処理終了"
    # 待機に移行しない場合
    return non_repeat if action == "待機に移行しない"
    # 初期位置変更の場合
    return @battler.change_base_position(self.x, self.y) if action == "初期位置変更"
    # 初期位置変更解除の場合
    return @battler.base_position if action == "初期位置変更解除"
    # ターゲット変更の場合  
    return change_target if action == "target"
    # ターゲットのコラプス許可
    return send_action(action) if action == "コラプス許可"
    # アクティブ解除
    return send_action(action) if action == "アクティブ解除"
    # ステート付与の場合  
    return state_on if action == "sta+"
    # ステート解除の場合  
    return state_off if action == "sta-"
    # ゲーム全体のスピード変更の場合
    return Graphics.frame_rate = @active_action[1] if action == "fps"
    # 浮遊の場合  
    return floating if action == "float"
    # 強制アクションの場合  
    return force_action if @active_action.size == 4
    # 座標リセットの場合  
    return reseting if @active_action.size == 5
    # 移動の場合
    return moving if @active_action.size == 7
    # バトラーアニメの場合
    return battler_anime if @active_action.size == 9
    # アニメ飛ばしの場合
    return moving_anime if @active_action.size == 11
    # 終了の場合
    return anime_finish if action == "終了"
  end
  #--------------------------------------------------------------------------
  # ● 反転実行
  #--------------------------------------------------------------------------
  def mirroring  
    # すでに反転されていれば元に戻す
    if self.mirror
      self.mirror = false
      # 武器アニメも反映
      @weapon_R.mirroring if @anime_flug
    else
      self.mirror = true
      # 武器アニメも反映
      @weapon_R.mirroring if @anime_flug
    end
  end  
  #--------------------------------------------------------------------------
  # ● 回転実行
  #--------------------------------------------------------------------------
  def angling  
    # ジャンプを初期化
    jump_reset
    # 情報確認
    @angle_time = @active_action[1]
    start_angle = @active_action[2]
    end_angle = @active_action[3]
    @angle_reset = @active_action[4]
    # バックアタック時には逆に
    start_angle *= -1 if $back_attack
    end_angle *= -1 if $back_attack
    # エネミーは逆に
    start_angle *= -1 if @battler.is_a?(Game_Enemy)
    end_angle *= -1 if @battler.is_a?(Game_Enemy)
    # 時間が0以下なら即座に最終角度へ
    if @angle_time <= 0
      self.angle = end_angle
      return  @angle_time = 0
    end  
    # 回転時間から1フレームあたりの角度を出す
    @angling = (end_angle - start_angle) / @angle_time
    # 割り切れない余りを初期角度に
    @angle = (end_angle - start_angle) % @angle_time + start_angle
  end
  #--------------------------------------------------------------------------
  # ● 拡大縮小実行
  #--------------------------------------------------------------------------
  def zooming  
    # ジャンプを初期化
    jump_reset
    # 情報確認
    @zoom_time = @active_action[1]
    zoom_x = @active_action[2] - 1
    zoom_y = @active_action[3] - 1
    @zoom_reset = @active_action[4]
    @zoom_x = @zoom_y = 1
    # 時間が0以下ならスキップ
    return @zoom_time = 0 if @zoom_time <= 0
    # 拡大時間から1フレームあたりの拡大率を出す
    @zooming_x = zoom_x / @zoom_time
    @zooming_y = zoom_y / @zoom_time
  end  
  #--------------------------------------------------------------------------
  # ● 残像開始
  #--------------------------------------------------------------------------
  def mirage_on
    # 戦闘不能時には残像させない
    return if @battler.dead?
    @mirage0 = Sprite.new(self.viewport)
    @mirage1 = Sprite.new(self.viewport)
    @mirage2 = Sprite.new(self.viewport)
    @mirage_flug = true
    @mirage_count = 0
  end  
  #--------------------------------------------------------------------------
  # ● 残像表示
  #--------------------------------------------------------------------------
  def mirage(body)
    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
    body.mirror = self.mirror
    body.angle = @angle
    body.opacity = 160
    body.zoom_x = self.zoom_x
    body.zoom_y = self.zoom_y   
    body.src_rect.set(@sx, @sy, @width, @height) if @anime_flug
    body.src_rect.set(0, 0, @width, @height) unless @anime_flug
  end   
  #--------------------------------------------------------------------------
  # ● 残像終了
  #--------------------------------------------------------------------------
  def mirage_off
    @mirage_flug = false
    @mirage0.dispose if @mirage0 != nil
    @mirage1.dispose if @mirage1 != nil
    @mirage2.dispose if @mirage2 != nil
  end   
  #--------------------------------------------------------------------------
  # ● ピクチャ表示
  #--------------------------------------------------------------------------
  def picture
    # 移動開始位置を確認
    pic_x = @active_action[1]
    pic_y = @active_action[2]
    # 移動終了位置を確認
    pic_end_x = @active_action[3]
    pic_end_y = @active_action[4]
    @picture_time = @active_action[5]
    # 時間で割り、1フレーム当たりの移動速度を計算
    @moving_pic_x = (pic_end_x - pic_x)/ @picture_time
    @moving_pic_y = (pic_end_y - pic_y)/ @picture_time
    # 割り切れない場合最初に加算
    plus_x = (pic_end_x - pic_x)% @picture_time
    plus_y = (pic_end_y - pic_y)% @picture_time
    # ピクチャ表示
    @picture.bitmap = Cache.picture(@active_action[7])
    @picture.x = pic_x + plus_x
    @picture.y = pic_y + plus_y
    # Z座標調整
    @picture.z = 1
    @picture.z = 1000 if @active_action[6]
    @picture.visible = true
  end
  #--------------------------------------------------------------------------
  # ● グラフィックファイル変更
  #--------------------------------------------------------------------------
  def graphics_change  
    # アクター限定
    return if @battler.is_a?(Game_Enemy)
    # グラフィック変更
    @battler_name = @active_action[2]
    # 戦闘後も変更を反映させるならキャラチップもここで変更
    @battler.graphic_change(@active_action[2]) unless @active_action[1]
  end  
  #--------------------------------------------------------------------------
  # ● 戦闘アニメ表示 [判別,ID,対象,反転,ウエイト,二刀フラグ]
  #--------------------------------------------------------------------------
  def battle_anime
    # エネミーの二刀フラグアニメ処理はキャンセル
    return if @active_action[5] && [email protected]?
    # 二刀ではないアクターの二刀フラグアニメ処理はキャンセル
    return if @active_action[5] && @battler.weapons[1] == nil
    # 二刀で右(上に配置された)武器がなく左(下に配置)だけ持ってる場合
    if @battler.actor?
      return if !@active_action[5] && @battler.weapons[0] == nil && @battler.weapons[1] != nil
    end
    anime_id = @active_action[1]
    # バックアタック時にアニメ画像を反転
    if $back_attack
     mirror = true if @active_action[3] == false
      mirror = false if @active_action[3]
    end
    # ウエイト設定
    @wait = $data_animations[anime_id].frame_max * 4 if @active_action[4]
    # 武器とスキルアニメの場合
    if anime_id < 0
      # 行動の種類でアニメ先を分岐
      if @battler.action.skill? && anime_id != -2
        anime_id = @battler.action.skill.animation_id
      elsif @battler.action.item? && anime_id != -2
        anime_id = @battler.action.item.animation_id
      else
        # 武器がなければ素手アニメを使用
        anime_id = N01::NO_WEAPON
        if @battler.actor?
          weapon_id = @battler.weapon_id
          anime_id = $data_weapons[weapon_id].animation_id if weapon_id != 0
          # 二刀アニメの場合
          anime_id = @battler.atk_animation_id2 if @active_action[5]
        else
          weapon_id = @battler.weapon
          anime_id = $data_weapons[weapon_id].animation_id if weapon_id != 0
        end
      end
      # ダメージ表示のアニメなら、ダメージ計算を先に済ませるため処理を中断
      damage_action = [anime_id, mirror, true]
      return @battler.play = ["対象アニメ",damage_action] if @battler.active
    end
    # アニメ実行
    if @active_action[2] == 0 && $data_animations[anime_id] != nil
      @battler.animation_id = anime_id
      @battler.animation_mirror = mirror
    elsif $data_animations[anime_id] != nil
      for target in @target_battler
        target.animation_id = anime_id
        target.animation_mirror = mirror
      end  
    end
  end
  #--------------------------------------------------------------------------
  # ● ふきだしアニメ表示
  #--------------------------------------------------------------------------
  def balloon_anime
    return if self.opacity == 0
    if @balloon == nil
      @balloon = Sprite.new
      @balloon.bitmap = Cache.system("Balloon")
      @balloon_height = @height * 5 / 4 if @anime_flug
      @balloon_height = @height unless @anime_flug
    end
    @balloon_id = @active_action[1]
    @balloon_loop = @active_action[2]
    @balloon_duration = 64
    @balloon_back = false
    update_balloon
    @balloon.visible = true
  end  
  #--------------------------------------------------------------------------
  # ● BGM/BGS/SE演奏
  #--------------------------------------------------------------------------
  def sound   
    # 情報を取得
    pitch = @active_action[2]
    vol =  @active_action[3]
    name = @active_action[4]
    # 実行
    case @active_action[1]
    when "se"
      Audio.se_play("Audio/SE/" + name, vol, pitch)
    when "bgm"
      # 名前指定のない場合、現在のBGMを変えないように
      if @active_action[4] == ""
        now_bgm = RPG::BGM.last
        name = now_bgm.name
      end
      Audio.bgm_play("Audio/BGM/" + name, vol, pitch)
    when "bgs"
      # 名前指定のない場合、現在のBGSを変えないように
      if @active_action[4] == ""
        now_bgs = RPG::BGS.last
        name = now_bgs.name
      end
      Audio.bgs_play("Audio/BGS/" + name, vol, pitch)
    end
  end
  #--------------------------------------------------------------------------
  # ● ゲーム変数操作
  #--------------------------------------------------------------------------
  def variable
    # オペランドチェック
    operand = @active_action[3]
    # 変数操作で分岐
    case @active_action[2]
    when 0 # 代入
      $game_variables[@active_action[1]] = operand
    when 1 # 加算
      $game_variables[@active_action[1]] += operand
    when 2 # 減算
      $game_variables[@active_action[1]] -= operand
    when 3 # 乗算
      $game_variables[@active_action[1]] *= operand
    when 4 # 除算
      $game_variables[@active_action[1]] /= operand
    when 5 # 剰余
      $game_variables[@active_action[1]] %= operand
    end
  end  
  #--------------------------------------------------------------------------
  # ● 二刀限定
  #--------------------------------------------------------------------------
  def two_swords
    # エネミーは処理させない
    return @action.shift unless @battler.actor?
    # 左(下部表示)に武器がなかったら次のアクションを除く
    return @action.shift if @battler.weapons[1] == nil
    # 行動配列の先頭からシフト
    active = @action.shift
    # 現在のアクションを決定
    @active_action = N01::ANIME[active]
    # ウエイト設定
    @wait = active.to_i if @active_action == nil
    # 単発アクション開始
    action
  end
  #--------------------------------------------------------------------------
  # ● 非二刀限定
  #--------------------------------------------------------------------------
  def non_two_swords
    # エネミーは処理させない
    return unless @battler.actor?
    # 左(下部表示)に武器があったら次のアクションを除く
    return @action.shift if @battler.weapons[1] != nil
    # 行動配列の先頭からシフト
    active = @action.shift
    # 現在のアクションを決定
    @active_action = N01::ANIME[active]
    # ウエイト設定
    @wait = active.to_i if @active_action == nil
    # 単発アクション開始
    action
  end
  #--------------------------------------------------------------------------
  # ● アクション条件
  #--------------------------------------------------------------------------
  def necessary
    nece1 = @active_action[3]
    nece2 = @active_action[4]
    # ターゲットチェック
    case @active_action[1]
    # 0自身 1ターゲット 2敵全体 3味方全体
    when 0
      target = [$game_party.members[@battler.index]] if @battler.is_a?(Game_Actor)
      target = [$game_troop.members[@battler.index]] if @battler.is_a?(Game_Enemy)
    when 1
      target = @target_battler
    when 2
      target = $game_troop.members
    when 3
      target = $game_party.members
    end
    # ターゲットが空の場合は失敗とみなす
    return start_action(@battler.recover_action) if target.size == 0
    # 内容チェック
    case @active_action[2]
    # ステートID指定だった場合
    when 0
      # 補足が正で「ステートにかかっている」、負は「かかっていない」が条件に
      state_on = true if nece2 > 0
      # 条件人数を出す
      state_member = nece2.abs
      # 0は仲間数を出す
      if nece2 == 0
        state_member = $game_party.members.size if @battler.is_a?(Game_Actor)
        state_member = $game_troop.members.size if @battler.is_a?(Game_Enemy)
      end  
      # ターゲットのステートチェックし人数をカウント
      for member in target
        state_member -= 1 if member.state?(nece1)
      end
      # 条件が満たされていればアクション続行
      if state_member == 0 && state_on
        return
      elsif state_member == nece2.abs
        return if state_on == nil
      end  
    # パラメータ指定だった場合
    when 1  
      # 補足が正で「数値以上」、負は「数値以下」が条件に
      num_over = true if nece2 > 0
      # 参照数値
      num = 0
      # ターゲットのパラメータチェック
      for member in target
        # 参照パラメータで分岐
        case  nece1
        when 0 # 現HP
          num += member.hp
        when 1 # 現MP
          num += member.mp
        when 2 # 攻撃力
          num += member.atk
        when 3 # 防御力
          num += member.def
        when 4 # 精神力
          num += member.spi
        when 5 # 敏捷性
          num += member.agi
        end
      end
      # 平均を出す
      num = num / target.size
      # 条件が満たされていればアクション続行
      if num > nece2.abs && num_over
        return
      elsif num < nece2.abs
        return if num_over == nil
      end
    # スイッチ指定だった場合
    when 2
      # 条件が満たされていればアクション続行
      if $game_switches[nece1]
        # 補足がtrueで「スイッチON」、falseは「スイッチOFF」が条件に
        return if nece2
      # スイッチがOFFの場合はON時とは逆に  
      else
        return unless nece2
      end  
    # 変数指定だった場合
    when 3
      # 補足が正で「数値以上」、負は「数値以下」が条件に
      if nece2 > 0
        return if $game_variables[nece1] > nece2
      else
        return unless $game_variables[nece1] > nece2.abs
      end
    # 習得スキル指定だった場合
    when 4
      # スキル条件人数を出す
      skill_member = nece2.abs
      for member in target
        skill_member -= 1 if member.skill_learn?(nece1)
        # 条件確認
        return if skill_member == 0
      end  
    end
    # 条件を満たせなければ以降のアクションを中断
    return @action = ["終了"] if @non_repeat
    # 防御中は不自然に見えないように座標復帰させない
    action = @battler.recover_action
    action = @battler.defence if @battler.guarding?
    return start_action(action)
  end  
  #--------------------------------------------------------------------------
  # ● スキル派生
  #--------------------------------------------------------------------------
  def derivating
    # 未修得スキルは派生不可なら
    return unless @active_action[2] && [email protected]_learn?(@active_action[3])
    # 確率分岐
    return if rand(100) > @active_action[1]
    # 派生成功
    @battler.derivation = @active_action[3]
    # 以降のアクションを中断
    @action = ["終了"]
  end
  #--------------------------------------------------------------------------
  # ● 個別処理開始
  #--------------------------------------------------------------------------
  def individual_action
    # リピートフラグオン
    @battler.individual = true
    # リピートアクションを保持
    @individual_act = @action.dup
    # ターゲットを保持し、行動ターゲットをひとつずつ抜き出す
    send_action(["個別処理"])
    @individual_targets = @target_battler.dup
    @target_battler = [@individual_targets.shift]
  end
  #--------------------------------------------------------------------------
  # ● 個別処理終了
  #--------------------------------------------------------------------------
  def individual_action_end
    # ターゲットが残っていないなら行動終了
    return @battler.individual = false if @individual_targets.size == 0
    @action = @individual_act.dup
    @target_battler = [@individual_targets.shift]
  end  

wuoismiao

#--------------------------------------------------------------------------
  # ● 待機に移行しない
  #--------------------------------------------------------------------------
  def non_repeat
    @repeat_action = []
    @non_repeat = true
    anime_finish
  end  
  #--------------------------------------------------------------------------
  # ● ターゲット変更 action = [判別, 変更する対象, 変更先]
  #--------------------------------------------------------------------------
  def change_target
    # 自身の変更したターゲットを元に戻す
    return @target_battler = @now_targets.dup if @active_action[2] == 3
    # 送るターゲット情報
    target = [@battler] if @active_action[2] == 0
    target = @target_battler.dup if @active_action[2] != 0
    # 自身のターゲットを送った相手にする場合、現在のターゲットを記憶
    if @active_action[2] == 2
      @now_targets = @target_battler.dup
      @target_battler = []
    end  
    # 送るターゲットがインデックス指定の場合
    if @active_action[1] >= 1000
      members = $game_party.members if @battler.actor?
      members = $game_troop.members unless @battler.actor?
      index = @active_action[1] - 1000
      if index < members.size
        if members[index].exist? && @battler.index != index
          # ターゲット変更
          members[index].force_target = ["N01target_change", target]
          # 自身のターゲットを送った相手にする場合
          @target_battler = [members[index]] if @active_action[2] == 2
          change = true
        else
          for member in members
            next if @battler.index == member.index
            next unless member.exist?
            member.force_target = ["N01target_change", target]
            @target_battler = [member] if @active_action[2] == 2
            break change = true
          end
        end
      end
    # 送るターゲットがステートID指定だった場合
    elsif @active_action[1] > 0
      for member in $game_party.members + $game_troop.members
        if member.state?(@active_action[1])
          member.force_target = ["N01target_change", target]
          @target_battler.push(member) if @active_action[2] == 2
          change = true
        end  
      end  
    # 送るターゲットが習得スキル指定だった場合
    elsif @active_action[1] < 0
      skill_id = @active_action[1].abs
      for actor in $game_party.members
        if actor.skill_learn?(skill_id)
          actor.force_target = ["N01target_change", target]
          @target_battler.push(target) if @active_action[2] == 2
          change = true
        end  
      end
    # 送るターゲットがターゲットだった場合
    else
      for member in @target_battler
        member.force_target = ["N01target_change", target]
        @target_battler.push(member) if @active_action[2] == 2
        change = true
      end
    end
    # 条件を満たせなければ以降のアクションを中断
    return if change
    return @action = ["終了"] if @non_repeat
    return start_action(@battler.recover_action)
  end   
  #--------------------------------------------------------------------------
  # ● ステート付与
  #--------------------------------------------------------------------------
  def state_on  
    state_id = @active_action[2]
    # 対象で分岐
    case @active_action[1]
    when 0
      @battler.add_state(state_id)
    when 1
      if @target_battler != nil
        for target in @target_battler
          target.add_state(state_id)
        end
      end
    when 2
      for target in $game_troop.members
        target.add_state(state_id)
      end
    when 3
      for target in $game_party.members
        target.add_state(state_id)
      end
    when 4
      for target in $game_party.members
        if target.index != @battler.index
          target.add_state(state_id)
        end  
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● ステート解除
  #--------------------------------------------------------------------------
  def state_off  
    state_id = @active_action[2]
    # 対象で分岐
    case @active_action[1]
    when 0
      @battler.remove_state(state_id)
    when 1
      if @target_battler != nil
        for target in @target_battler
          target.remove_state(state_id)
        end
      end
    when 2
      for target in $game_troop.members
        target.remove_state(state_id)
      end
    when 3
      for target in $game_party.members
        target.remove_state(state_id)
      end
    when 4
      for target in $game_party.members
        if target.index != @battler.index
          target.remove_state(state_id)
        end  
      end
    end
  end  
  #--------------------------------------------------------------------------
  # ● 浮遊実行
  #--------------------------------------------------------------------------
  def floating  
    # ジャンプを初期化
    jump_reset
    # 情報確認
    @jump_plus = @active_action[1]
    float_end = @active_action[2]
    @float_time = @active_action[3]
    # １フレーム当たりの移動高度を計算
    @float_up = (float_end - @jump_plus)/ @float_time
    # 浮遊が完了するまで次のアクションに行かない
    @wait = @float_time
    # 浮遊アニメ設定を反映
    if @anime_flug
      move_anime = N01::ANIME[@active_action[4]]
      # グラフィック指定がない場合はスキップ
      if move_anime != nil
        # 現在のアクションを上書き
        @active_action = move_anime
        # バトラーアニメ開始
        battler_anime
        # 浮遊が完了したら即アニメが終わるように
        @anime_end = true
      end
    end
    # 初期高度に浮遊
    @battler.jump = @jump_plus
  end      
  #--------------------------------------------------------------------------
  # ● 強制アクション
  #--------------------------------------------------------------------------
  def force_action
    # アクションが単発か通しか判別
    kind = @active_action[0]
    # 復帰の有無をチェック
    rebirth = @active_action[2]
    # 強制アクション内容を取得
    play = @active_action[3]
    # 上3つの情報をまとめて格納
    action = [kind,rebirth,play]
    # ターゲットがインデックス指定の場合
    if @active_action[1] >= 1000
      members = $game_party.members if @battler.actor?
      members = $game_troop.members unless @battler.actor?
      index = @active_action[1] - 1000
      if index < members.size
        if members[index].exist? && @battler.index != index
          # バトラー情報に渡す
          return members[index].force_action = action
        else
          for target in members
            next if @battler.index == target.index
            next unless target.exist?
            force = true
            break target.force_action = action
          end
        end
      end
      # 条件を満たせなければ以降のアクションを中断
      return if force
      return @action = ["終了"] if @non_repeat
      return start_action(@battler.recover_action)
    # ターゲット指定の場合  
    elsif @active_action[1] == 0
      for target in @target_battler
        target.force_action = action if target != nil
      end
    # ステートID指定だった場合  
    elsif @active_action[1] > 0
      for target in $game_party.members + $game_troop.members
        target.force_action = action if target.state?(@active_action[1])
      end
    # 習得スキル指定だった場合  
    elsif @active_action[1] < 0  
      # エネミーは処理させない
      return if @battler.is_a?(Game_Enemy)
      for actor in $game_party.members
        # 自分は除く
        unless actor.id == @battler.id
          # バトラー情報に渡す
          actor.force_action = action if actor.skill_id_learn?(@active_action[1].abs)
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● 座標リセット実行
  #--------------------------------------------------------------------------
  def reseting
    # ジャンプを初期化
    jump_reset
    # 回転を元に戻す
    self.angle = 0
    # 情報確認
    @distanse_x   = @move_x * -1
    @distanse_y   = @move_y * -1
    @move_speed_x = @active_action[1]
    @move_speed_y = @move_speed_x
    @move_boost_x = @active_action[2]
    @move_boost_y = @move_boost_x
    @jump         = @active_action[3]
    # 移動計算
    move_distance
    # 移動アニメ設定を反映
    if @anime_flug
      move_anime = N01::ANIME[@active_action[4]]
      # グラフィック指定がない場合はスキップ
      if move_anime != nil
        # 現在のアクションを上書き
        @active_action = move_anime
        # バトラーアニメ開始
        battler_anime
      end
      # 移動が完了したら即アニメが終わるように
      @anime_end = true
    end
  end
  #--------------------------------------------------------------------------
  # ● 移動実行
  #--------------------------------------------------------------------------
  def moving  
    # ジャンプを初期化
    jump_reset
    # X軸移動を便宜上抜き出す
    xx = @active_action[1]
    # バックアタック時にはX軸を逆に
    xx *= -1 if $back_attack
    # 移動目標のターゲットを確認
    case @active_action[0]
    when 0 # 自身
      @distanse_x = xx
      @distanse_y = @active_action[2]
    when 1 # ターゲット
      # ターゲットが決まってない場合、自身に変換
      if @target_battler == nil
        @distanse_x = xx
        @distanse_y = @active_action[2]
      else
        # ターゲット対象をひとつずつチェック
        target_x = 0
        target_y = 0
        time = 0
        for i in 0...@target_battler.size
          if @target_battler != nil
            time += 1
            target_x += @target_battler.position_x
            target_y += @target_battler.position_y
          end  
        end
        # ターゲットが空だった場合、自身に変換
        if time == 0
          @distanse_x = xx
          @distanse_y = @active_action[2]
        else  
          # 複数ターゲットの中心を計算
          target_x = target_x / time
          target_y = target_y / time
          # 最終的な移動距離を算出
          @distanse_y = target_y - self.y + @active_action[2]
          # X座標はアクターとエネミーで逆計算
          if @battler.is_a?(Game_Actor)
            @distanse_x = target_x - self.x + xx
          else
            @distanse_x = self.x - target_x + xx
          end  
        end  
      end  
    when 2 # 画面
      # X座標はアクターとエネミーで逆計算
      if @battler.is_a?(Game_Actor)
        @distanse_x = xx - self.x
        @distanse_x = Graphics.width + xx - self.x if $back_attack
      else
        @distanse_x = self.x - xx
        @distanse_x = self.x - (Graphics.width + xx) if $back_attack
      end
      @distanse_y = @active_action[2] - self.y
    when 3 # 初期位置
      # X座標はアクターとエネミーで逆計算
      if @battler.is_a?(Game_Actor)
        @distanse_x = xx + @battler.base_position_x - self.x
      else
        @distanse_x = xx + self.x - @battler.base_position_x
      end
      @distanse_y = @active_action[2] + @battler.base_position_y - @battler.position_y
    end
    @move_speed_x = @active_action[3]
    @move_speed_y = @active_action[3]
    @move_boost_x = @active_action[4]
    @move_boost_y = @active_action[4]
    @jump         = @active_action[5]
    @jump_plus = 0
    # 移動計算
    move_distance
    # 移動アニメ設定を反映
    if @anime_flug
      move_anime = N01::ANIME[@active_action[6]]
      # グラフィック指定がない場合はスキップ
      if move_anime != nil
        # 現在のアクションを上書き
        @active_action = move_anime
        # バトラーアニメ開始
        battler_anime
      end  
      # 移動が完了したら即アニメが終わるように
      @anime_end = true
    end
  end
  #--------------------------------------------------------------------------
  # ● 移動計算
  #--------------------------------------------------------------------------
  def move_distance
    # 速度が0の場合、その場に留まる
    if @move_speed_x == 0
      @moving_x = 0
      @moving_y = 0
    else  
      # １フレームあたりの移動距離を計算
      @moving_x = @distanse_x / @move_speed_x
      @moving_y = @distanse_y / @move_speed_y
      # 余った距離はこの時点で移動し消化
      over_x = @distanse_x % @move_speed_x
      over_y = @distanse_y % @move_speed_y
      @move_x += over_x
      @move_y += over_y
      @battler.move_x = @move_x
      @battler.move_y = @move_y
      @distanse_x -= over_x
      @distanse_y -= over_y
    end  
    # 移動があるかどうかの判定
    if @distanse_x == 0
      @move_speed_x = 0
    end
    if @distanse_y == 0
      @move_speed_y = 0
    end
    # X座標移動計算
    # 加減速による移動フレーム数の修正
    boost_x = @moving_x
    move_x = 0
    # 加速がある場合
    if @move_boost_x > 0 && @distanse_x != 0
      # 加減速の正負を左右移動に合わせて変換
      if @distanse_x == 0
        @move_boost_x = 0
      elsif @distanse_x < 0
        @move_boost_x *= -1
      end
      # 距離の変化を事前計算
      for i in 0...@move_speed_x
        boost_x += @move_boost_x
        move_x += boost_x
        # オーバー距離を記録
        over_distance = @distanse_x - move_x
        # 右移動で距離オーバーする直前が何フレーム目だったか記録
        if @distanse_x > 0 && over_distance < 0
          @move_speed_x = i
          break
        # 左移動で距離オーバーする直前が何フレーム目だったか記録
        elsif @distanse_x < 0 && over_distance > 0
          @move_speed_x = i
          break
        end
      end
      # オーバー距離を一回前に戻す
      before = over_distance + boost_x
      # 余った距離を等速移動させるフレーム数を加算
      @move_speed_plus_x = (before / @moving_x).abs
      # それでも余った距離はこの時点で移動し消化
      @move_x += before % @moving_x
      @battler.move_x = @move_x
    # 減速がある場合  
    elsif @move_boost_x < 0 && @distanse_x != 0
      # 加減速の正負を左右移動に合わせて変換
      if @distanse_x == 0
        @move_boost_x = 0
      elsif @distanse_x < 0
        @move_boost_x *= -1
      end
      # 距離の変化を事前計算
      for i in 0...@move_speed_x
        boost_x += @move_boost_x
        move_x += boost_x
        # 足りない距離を記録
        lost_distance = @distanse_x - move_x
        before = lost_distance
        # 右移動で速度が0になる直前が何フレーム目だったか記録
        if @distanse_x > 0 && boost_x < 0
          @move_speed_x = i - 1
          # 足りない距離を一回前に戻す
          before = lost_distance + boost_x
          break
        # 左移動で速度が0になる直前が何フレーム目だったか記録
        elsif @distanse_x < 0 && boost_x > 0
          @move_speed_x= i - 1
          # 足りない距離を一回前に戻す
          before = lost_distance + boost_x
          break
        end
      end
      # 足りない距離を等速移動させるフレーム数を加算
      plus = before / @moving_x
      @move_speed_plus_x = plus.abs
      # それでも余った距離はこの時点で移動し消化
      @move_x += before % @moving_x
      @battler.move_x = @move_x
    end
    # Y座標移動計算
    # 加減速による移動フレーム数の修正
    boost_y = @moving_y
    move_y = 0
    # 加速がある場合
    if @move_boost_y > 0 && @distanse_y != 0
      # 加減速の正負を左右移動に合わせて変換
      if @distanse_y == 0
        @move_boost_y = 0
      elsif @distanse_y < 0
        @move_boost_y *= -1
      end
      # 距離の変化を事前計算
      for i in 0...@move_speed_y
        boost_y += @move_boost_y
        move_y += boost_y
        # オーバー距離を記録
        over_distance = @distanse_y - move_y
        # 右移動で距離オーバーする直前が何フレーム目だったか記録
        if @distanse_y > 0 && over_distance < 0
          @move_speed_y = i
          break
        # 左移動で距離オーバーする直前が何フレーム目だったか記録
        elsif @distanse_y < 0 && over_distance > 0
          @move_speed_y = i
          break
        end
      end
      # オーバー距離を一回前に戻す
      before = over_distance + boost_y
      # 余った距離を等速移動させるフレーム数を加算
      @move_speed_plus_y = (before / @moving_y).abs
      # それでも余った距離はこの時点で移動し消化
      @move_y += before % @moving_y
      @battler.move_y = @move_y
    # 減速がある場合  
    elsif @move_boost_y < 0 && @distanse_y != 0
      # 加減速の正負を左右移動に合わせて変換
      if @distanse_y == 0
        @move_boost_y = 0
      elsif @distanse_y < 0
        @move_boost_y *= -1
      end
      # 距離の変化を事前計算
      for i in 0...@move_speed_y
        boost_y += @move_boost_y
        move_y += boost_y
        # 足りない距離を記録
        lost_distance = @distanse_y - move_y
        before = lost_distance
        # 右移動で速度が0になる直前が何フレーム目だったか記録
        if @distanse_y > 0 && boost_y < 0
          @move_speed_y = i
          # 足りない距離を一回前に戻す
          before = lost_distance + boost_y
          break
        # 左移動で速度が0になる直前が何フレーム目だったか記録
        elsif @distanse_y < 0 && boost_y > 0
          @move_speed_y = i
          # 足りない距離を一回前に戻す
          before = lost_distance + boost_y
          break
        end
      end
      # 足りない距離を等速移動させるフレーム数を加算
      plus = before / @moving_y
      @move_speed_plus_y = plus.abs
      # それでも余った距離はこの時点で移動し消化
      @move_y += before % @moving_y
      @battler.move_y = @move_y
    end
    # 移動完了時間を算出
    x = @move_speed_plus_x + @move_speed_x
    y = @move_speed_plus_y + @move_speed_y
    if x > y
      end_time = x
    else
      end_time = y
    end
    # 移動が完了するまで次のアクションに行かない
    @wait = end_time
    # ジャンプ計算
    if @jump != 0
      # 移動がなくジャンプのみの場合
      if @wait == 0
        # 時間に計上
        @wait = @active_action[3]
      end  
      # 移動完了時間からジャンプ時間を算出
      @jump_time = @wait / 2
      # 割り切れない場合の余り時間
      @jump_time_plus = @wait % 2
      # ジャンプの正負を判別
      @jump_sign = 0
      @jump_sign2 = 0
      if @jump < 0
        @jump_sign = -1
        @jump_sign2 = 1
        @jump = @jump * -1
      else
        @jump_sign = 1
        @jump_sign2 = -1
      end
      # ジャンプ初速度を決定
      @jump_up = 2 ** @jump * @jump_sign
      # ジャンプ時間の端数を微調整
      if @jump_time == 0
        @jump_up = 0
      elsif @jump_time != 1
        @jump_size = @jump_up * @jump_sign * @jump_sign2
      else
        @jump_size = @jump_up * 2 * @jump_sign * @jump_sign2
        @jump_flug = true
      end  
    end
  end
  #--------------------------------------------------------------------------
  # ● バトラーアニメ開始
  #--------------------------------------------------------------------------
  def battler_anime
    # アニメ設定を反映
    @anime_kind  = @active_action[1]
    @anime_speed = @active_action[2]
    @anime_loop  = @active_action[3]
    # ウエイト時間があれば加算
    @unloop_wait = @active_action[4]
    @anime_end = true
    # 武器アクションがある場合だけ更新する
    if @weapon_R != nil && @active_action[8] != ""
      # 武器の設定をチェック
      weapon_kind = N01::ANIME[@active_action[8]]
      # エネミーと二刀ではないアクターの二刀フラグアニメ処理はキャンセル
      two_swords_flug = weapon_kind[11]
      return if two_swords_flug && [email protected]?
      return if two_swords_flug && @battler.weapons[1] == nil && @battler.actor?
      if @battler.actor? && @battler.weapons[0] == nil && !two_swords_flug
        @weapon_R.action_reset
      elsif @battler.actor? && @battler.weapons[1] == nil && two_swords_flug
        @weapon_R.action_reset
      elsif [email protected]? && @battler.weapon == 0
        @weapon_R.action_reset
      else
        # 初期化
        @weapon_R.action_reset
        # アニメパターンが固定だった場合の武器位置を取得
        if @active_action[5] != -1
          @weapon_R.freeze(@active_action[5])
        end
        # 武器画像を設定
        @weapon_R.weapon_graphics unless two_swords_flug
        @weapon_R.weapon_graphics(true) if two_swords_flug
        # 武器アクションを渡す
        @weapon_R.weapon_action(@active_action[8],@anime_loop)
        @weapon_action = true
        # 最初の武器アクションを更新
        @weapon_R.action
      end
    elsif @weapon_R != nil
      @weapon_R.action_reset
    end  
    @anime_end = false
    # アニメパターンが固定だった場合
    if @active_action[5] != -1
      # フラグオン
      @anime_freeze = true
      # アニメが常に終了しているとみなす
      @anime_end = true
    # 通常のアニメ更新の場合  
    else  
      @anime_freeze = false
      # 最初のアニメパターンを更新
      @pattern = 0
      # 武器アニメがある時だけフレーム更新
      if @weapon_action && @weapon_R != nil
        @weapon_R.action
        @weapon_R.update
      end
    end  
    @pattern_back = false
    @frame = @anime_speed
    # Z座標設定
    @battler.move_z = @active_action[6]
    # 影の有無
    if @shadow != nil
      @shadow.visible = true if @active_action[7]
      @shadow.visible = false unless @active_action[7]
      @shadow.visible = false if @skip_shadow
    end
    # ナンバリングから読み取るファイル名を分岐
    if @active_action[0] == 0
      file_name = @battler_name
    else
      file_name = @battler_name + "_" + @active_action[0].to_s
    end  
    # アニメしないバトラーなら処理終了
    return unless @anime_flug
    self.bitmap = Cache.character(file_name)
    # 転送元の矩形を設定
    @sx = @pattern * @width
    @sy = @anime_kind * @height
    @sx = @active_action[5] * @width if @anime_freeze
    self.src_rect.set(@sx, @sy, @width, @height)
  end
  #--------------------------------------------------------------------------
  # ● アニメ飛ばし
  #--------------------------------------------------------------------------
  def moving_anime
    # まだ前のアニメ飛ばしが残っているなら初期化
    @move_anime.action_reset if @anime_moving
    @anime_moving = true
    # バックアタック中はアニメ、武器画像反転
    mirror = false
    mirror = true if $back_attack
    # アニメID
    id = @active_action[1]
    # 対象
    target = @active_action[2]
    x = y = mem = 0
    # 対象が単体の場合
    if target == 0
      # ターゲットが決まってない場合、自身に変換
      if @target_battler == nil
        x = self.x
        y = self.y
      else
        # ターゲットが空の場合、自身に変換
        if @target_battler[0] == nil
          x = self.x
          y = self.y
        else  
          # 最初に入っているターゲットに対象決定
          x = @target_battler[0].position_x
          y = @target_battler[0].position_y
        end  
      end  
    # 対象が敵の中心の場合  
    elsif target == 1
      # 自身がアクターの場合はエネミーの中心を計算
      if @battler.is_a?(Game_Actor)
        for target in $game_troop.members
          x += target.position_x
          y += target.position_y
          mem += 1
        end
        x = x / mem
        y = y / mem
      # 自身がエネミーの場合はアクターの中心を計算
      else
        for target in $game_party.members
          x += target.position_x
          y += target.position_y
          mem += 1
        end
        x = x / mem
        y = y / mem
      end
    # 対象が味方の中心の場合  
    elsif target == 2
      # 自身がアクターの場合はアクターの中心を計算
      if @battler.is_a?(Game_Actor)
        for target in $game_party.members
          x += target.position_x
          y += target.position_y
          mem += 1
        end
        x = x / mem
        y = y / mem
      # 自身がエネミーの場合はエネミーの中心を計算
      else
        for target in $game_troop.members
          x += target.position_x
          y += target.position_y
          mem += 1
        end
        x = x / mem
        y = y / mem
      end
    # 対象が自身の場合  
    else
      x = self.x
      y = self.y
    end  
    # 開始位置の微調整
    plus_x = @active_action[6]
    plus_y = @active_action[7]
    # エネミーはX軸を逆に
    plus_x *= -1 if @battler.is_a?(Game_Enemy)
    # 最終的な移動距離を算出
    distanse_x = x - self.x - plus_x
    distanse_y = y - self.y - plus_y
    # 飛ばしタイプ
    type = @active_action[3]
    # 速度
    speed = @active_action[4]
    # 軌道
    orbit = @active_action[5]
    # 自身が開始位置なら
    if @active_action[8] == 0
      @move_anime.base_x = self.x + plus_x
      @move_anime.base_y = self.y + plus_y
    # 対象が開始位置なら
    elsif @active_action[8] == 1
      @move_anime.base_x = x + plus_x
      @move_anime.base_y = y + plus_y
      # 距離を反対に
      distanse_y = distanse_y * -1
      distanse_x = distanse_x * -1
    # 動かさないなら
    else
      @move_anime.base_x = x
      @move_anime.base_y = y
      distanse_x = distanse_y = 0
    end
    # 武器アクションなしは武器表示しない
    if @active_action[10] == ""
      weapon = ""  
    # アニメなしエネミーは武器表示しない
    elsif @anime_flug != true
      weapon = ""  
    # 武器アクションがある場合
    else
      # 飛ばす武器グラフィックが指定されているかチェック
      if @battler.is_a?(Game_Actor)
        battler = $game_party.members[@battler.index]
        weapon_id = battler.weapon_id
      else  
        battler = $game_troop.members[@battler.index]
        weapon_id = battler.weapon
      end  
      # 素手でなければ
      if weapon_id != 0
        weapon_file = $data_weapons[weapon_id].flying_graphic
        # 別画像が指定されていなければ既存の武器グラフィックを取得
        if weapon_file == ""
          weapon_name = $data_weapons[weapon_id].graphic
          icon_weapon = false
          # さらに指定がなければアイコングラフィックを利用
          if weapon_name == ""
            weapon_name = $data_weapons[weapon_id].icon_index
            icon_weapon = true
          end  
        # 指定されていればそのグラフィック名を取得  
        else
          icon_weapon = false
          weapon_name = weapon_file
        end
        # 武器アクション情報を取得
        weapon = @active_action[10]
      # 素手なら表示しない
      else
        weapon = ""
      end
    end
    # Z座標を決定
    @move_anime.z = 1
    @move_anime.z = 1000 if @active_action[9]
    # 以上の情報を全てアニメ飛ばしスプライトに送る
    @move_anime.anime_action(id,mirror,distanse_x,distanse_y,type,speed,orbit,weapon,weapon_name,icon_weapon)
  end  
  #--------------------------------------------------------------------------
  # ● アクション終了
  #--------------------------------------------------------------------------
  def anime_finish
    # 個別処理終了が省略された場合リピートさせる
    return individual_action_end if @individual_targets.size != 0
    # アクティブバトラーにアクション情報を格納
    send_action(@active_action[0]) if @battler.active
    # 残像があれば開放
    mirage_off if @mirage_flug
    # 待機アクションを繰り返す
    start_action(@repeat_action) unless @non_repeat
  end   
  #--------------------------------------------------------------------------
  # ● コラプスアクション
  #--------------------------------------------------------------------------
  def collapse_action
    @non_repeat = true
    @effect_type = COLLAPSE
    @collapse_type = @battler.collapse_type unless @battler.actor?
    @battler_visible = false unless @battler.actor?
    @effect_duration = N01::COLLAPSE_WAIT + 48 if @collapse_type == 2
    @effect_duration = 401 if @collapse_type == 3
  end  
  #--------------------------------------------------------------------------
  # ● ノーマルコラプス
  #--------------------------------------------------------------------------
  def normal_collapse
    if @effect_duration == 47
      Sound.play_enemy_collapse
      self.blend_type = 1
      self.color.set(255, 128, 128, 128)
    end
    self.opacity = 256 - (48 - @effect_duration) * 6 if @effect_duration <= 47
  end  
  #--------------------------------------------------------------------------
  # ● ボスコラプス
  #--------------------------------------------------------------------------
  def boss_collapse1
    if @effect_duration == 320
      Audio.se_play("Audio/SE/Absorb1", 100, 80)
      self.flash(Color.new(255, 255, 255), 60)
      viewport.flash(Color.new(255, 255, 255), 20)
    end
    if @effect_duration == 280
      Audio.se_play("Audio/SE/Absorb1", 100, 80)
      self.flash(Color.new(255, 255, 255), 60)
      viewport.flash(Color.new(255, 255, 255), 20)
    end
    if @effect_duration == 220
      Audio.se_play("Audio/SE/Earth4", 100, 80)
      reset
      self.blend_type = 1
      self.color.set(255, 128, 128, 128)
      self.wave_amp = 6
    end
    if @effect_duration < 220
      self.src_rect.set(0, @effect_duration / 2 - 110, @width, @height)
      self.x += 8 if @effect_duration % 4 == 0
      self.x -= 8 if @effect_duration % 4 == 2
      self.wave_amp += 1 if @effect_duration % 10 == 0
      self.opacity = @effect_duration
      return if @effect_duration < 50
      Audio.se_play("Audio/SE/Earth4", 100, 50) if @effect_duration % 50 == 0
    end
  end
end