橫板戰鬥出BUG了，該怎麼修改？(VA)

brackwind · 发表于 2012-10-25 07:10:48

加入我们，或者，欢迎回来。

您需要登录才可以下载或查看，没有帐号？注册会员

x

之前的主題過期了，所以再重新開帖請教
我把百里_飞柳大提供的多人戰鬥跟戰鬥中更換隊員的腳本(http://rpg.blue/thread-250698-2-1.html)用在fxwd大提供的腳本(http://rpg.blue/thread-247817-1-1.html)裡
結果四人時沒問題，但我試著改成六人參戰後進入戰鬥後，橫板戰鬥腳本就出現BUG

"橫板腳本222行發生問題"can't dup NilClass""

以下是出問題的部分，紅字是出問題的那行

# ● ベース座標をセット 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
#--------------------------------------------------------------------------

還有橫板腳本在戰鬥中用特技跟魔法時也會出現BUG
"undefined method 'frame_max' for nil:NilClass"

以下是出錯的片段
# ● 戦闘アニメ時間の取得
  #--------------------------------------------------------------------------
  def self.get_anime_time(anime_id)
return 0 if anime_id <= 0
return $data_animations[anime_id].frame_max * 4
  end
  #--------------------------------------------------------------------------

請問這兩個BUG該怎麼修改？

順便問一下
戰鬥中更換隊員的腳本有更換一次後過幾回合才能再更換的限制
請問要怎麼解除這個限制？謝謝

messiaz · 发表于 2014-1-29 23:08:10

第二个我也遇到问题了···感谢···

vince3725 · 发表于 2012-10-30 16:29:32

#==============================================================================
# ■ VXAce_SP1
#------------------------------------------------------------------------------
# 　プリセットスクリプトの不具合を修正します。ユーザー定義のスクリプト素材は、
# 原則としてこのセクションより下に配置してください。
#==============================================================================

#------------------------------------------------------------------------------
# 【修正内容】
#------------------------------------------------------------------------------
# ●イベントコマンド［ステートの変更］にて、同じステートの付加と解除を同時に実
# 行した際、二回目以降の付加が失敗する不具合を修正しました。
# ●イベントコマンド［アニメーションの表示］にて、表示中のアニメーションがマッ
# プのスクロールに同期しない不具合を修正しました。
# ●自動戦闘の行動が正常に選択されない不具合を修正しました。
# ●装備できなくなった装備品が外れたことにより、さらに別の装備品が装備できなく
# なったとき、その装備品が増殖してしまう不具合を修正しました。
# ●イベントコマンド［ピクチャの消去］を実行した後に余分な負荷がかかる不具合を
# 修正しました。
# ●移動ルートのオプション［移動できない場合は飛ばす］にチェックを入れた状態で
# トリガー［プレイヤーから接触］のイベントに接触すると、イベントが実行中であ
# っても起動予約がされてしまう不具合を修正しました。
# ●魔法反射されたスキルに対してステート有効度が反映されない不具合を修正しまし
# 　た。
# ●フォントのデフォルト設定にて太字または斜体を有効にしていても、ステータス画
# 面を切り替えたとき等に無効な状態に戻ってしまう不具合を修正しました。
#------------------------------------------------------------------------------
class Game_Battler
  attr_accessor :magic_reflection
  #--------------------------------------------------------------------------
  # ● 敵対関係の判定
  #--------------------------------------------------------------------------
  alias vxace_sp1_opposite? opposite?
  def opposite?(battler)
vxace_sp1_opposite?(battler) || battler.magic_reflection
  end
end
#------------------------------------------------------------------------------
class Game_Actor
  #--------------------------------------------------------------------------
  # ● 装備できない装備品を外す
  #    item_gain : 外した装備品をパーティに戻す
  #--------------------------------------------------------------------------
  alias vxace_sp1_release_unequippable_items release_unequippable_items
  def release_unequippable_items(item_gain = true)
loop do
   last_equips = equips.dup
   vxace_sp1_release_unequippable_items(item_gain)
   return if equips == last_equips
end
  end
  #--------------------------------------------------------------------------
  # ● 自動戦闘時の戦闘行動を作成
  #--------------------------------------------------------------------------
  def make_auto_battle_actions
@actions.size.times do |i|
   @actions[i] = make_action_list.max_by {|action| action.value }
end
  end
end
#------------------------------------------------------------------------------
class Game_Player
  #--------------------------------------------------------------------------
  # ● マップイベントの起動
  #    triggers : トリガーの配列
  #    normal : プライオリティ［通常キャラと同じ］かそれ以外か
  #--------------------------------------------------------------------------
  alias vxace_sp1_start_map_event start_map_event
  def start_map_event(x, y, triggers, normal)
return if $game_map.interpreter.running?
vxace_sp1_start_map_event(x, y, triggers, normal)
  end
end
#------------------------------------------------------------------------------
class Game_Picture
  #--------------------------------------------------------------------------
  # ● ピクチャの消去
  #--------------------------------------------------------------------------
  alias vxace_sp1_erase erase
  def erase
vxace_sp1_erase
@origin = 0
  end
end
#------------------------------------------------------------------------------
class Game_Interpreter
  #--------------------------------------------------------------------------
  # ● ステートの変更
  #--------------------------------------------------------------------------
  alias vxace_sp1_command_313 command_313
  def command_313
vxace_sp1_command_313
$game_party.clear_results
  end
end
#------------------------------------------------------------------------------
class Sprite_Character
  #--------------------------------------------------------------------------
  # ● 位置の更新
  #--------------------------------------------------------------------------
  alias vxace_sp1_update_position update_position
  def update_position
move_animation(@character.screen_x - x, @character.screen_y - y)
vxace_sp1_update_position
  end
  #--------------------------------------------------------------------------
  # ● アニメーションの移動
  #--------------------------------------------------------------------------
  def move_animation(dx, dy)
if @animation && @animation.position != 3
   @ani_ox += dx
   @ani_oy += dy
   @ani_sprites.each do |sprite|
      sprite.x += dx
      sprite.y += dy
   end
end
  end
end
#------------------------------------------------------------------------------
class Sprite_Picture
  #--------------------------------------------------------------------------
  # ● 転送元ビットマップの更新
  #--------------------------------------------------------------------------
  alias vxace_sp1_update_bitmap update_bitmap
  def update_bitmap
if @picture.name.empty?
   self.bitmap = nil
else
   vxace_sp1_update_bitmap
end
  end
end
#------------------------------------------------------------------------------
class Window_Base
  #--------------------------------------------------------------------------
  # ● フォント設定のリセット
  #--------------------------------------------------------------------------
  alias vxace_sp1_reset_font_settings reset_font_settings
  def reset_font_settings
vxace_sp1_reset_font_settings
contents.font.bold = Font.default_bold
contents.font.italic = Font.default_italic
  end
end
#------------------------------------------------------------------------------
class Scene_Battle
  #--------------------------------------------------------------------------
  # ● 魔法反射の発動
  #--------------------------------------------------------------------------
  alias vxace_sp1_invoke_magic_reflection invoke_magic_reflection
  def invoke_magic_reflection(target, item)
@subject.magic_reflection = true
vxace_sp1_invoke_magic_reflection(target, item)
@subject.magic_reflection = false
  end
end
  不兼容的地方用这个脚本

brackwind · 发表于 2012-10-27 20:32:12

刪掉碧軌的戰鬥系統，再找CP制戰鬥的腳本後，總算解決進入下場戰鬥時會當掉的問題
只是如果更換正在行動的角色時一樣會當掉
不過這部分只要不更換正在行動的角色就行了，基本上可以無視
至於CP條，因為我是六人參戰，所以有兩條CP條被藏在下方了，如果可以減少寬度應該就能容納六條
我從這裡找到的
http://temp.66rpg.com/thread-220872-1-1.html

不好意思讓你花費這麼多時間，不過方便再讓我提兩個問題嗎？
首先是關於VA的TP條
每場戰鬥開始時他的數值是隨機決定
不過我想讓TP值在戰鬥結束後保留下來，也就是進入下場戰鬥時TP值是上場戰鬥的數值
這要從哪個腳本的哪部分更改呢？

再來，這是我在其他網站找到的合體技腳本

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#_/ ◆ 連係スキル - KGC_CooperationSkill ◆ VX ◆
#_/ ◇ Last update : 2009/08/07 ◇
#_/----------------------------------------------------------------------------
#_/  複数のスキルを組み合わせ、別のスキルを発動させる機能です。
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/

#==============================================================================
# ★ カスタマイズ項目 - Customize BEGIN ★
#==============================================================================

module KGC
module CooperationSkill
  # ◆ 連係発動時の名前の区切り文字
  NAME_SEPARATOR = "、"

  # ◆ 連係元スキル発動
  #  true  : 連係元となるスキルもすべて発動する。
  #  false : 連係スキルのみ発動する。
  # ※ 併用するスクリプトによっては効果がない場合があります。
  EXECUTE_ORIGIN_SKILL = false

  # ◆ ターゲットが同じ場合のみ連係を発動
  #  true  : 元のスキルがすべて同じターゲット(または全体)の場合のみ発動。
  #          ※ ターゲットがランダムのスキルとは相性が良くありません。
  #  false : ターゲットが誰でもスキル条件さえ満たせば発動。
  #       連係スキルのターゲットは、発動時の行動者のターゲット。
  SAME_TARGET_ONLY = true

  # ◆ 敵連係スキル許可
  #  true  : 敵も連係スキル判定を行う。
  #  false : 敵は連係スキルを使用不可。
  PERMIT_ENEMY = true
end
end

#==============================================================================
# ☆ カスタマイズ項目終了 - Customize END ☆
#==============================================================================

$imported = {} if $imported == nil
$imported["CooperationSkill"] = true

module KGC
module CooperationSkill
  # 連係スキル用条件パラメータ
  PARAMS = {
:level_avg => "LEVEL_AVG|平均レベル",
:level_min => "LEVEL_MIN|最[小低]レベル",
:level_max => "LEVEL_MAX|最[大高]レベル",
  }

  # 連係スキル用属性・ステートリスト
  ARRAYS = {
:attack_element => "ATTACK_ELEMENT|攻撃属性",
:state       => "STATE|ステート",
  }

  module Regexp
module Skill
   # 連係スキル開始
   BEGIN_COOPERATE = /<(?:COOPERATION_SKILL|連[係繋携]スキル)>/i
   # 連係スキル終了
   END_COOPERATE = /<\/(?:COOPERATION_SKILL|連[係繋携]スキル)>/i
   # 必要スキルリスト
   NEED_SKILLS = /^\s*(?:NEED_SKILLS?|必要スキル)\s*(\d+(?:\s*,\s*\d+)*)\s*/i

   REG_NAME = '[^:\+\-\d\s]+'
   REG_OU = 'OVER|UNDER|以上|以下'

   # 条件パラメータ
   #  レベル 10 以上  など
   COOPERATE_PARAMS = /^\s*(#{REG_NAME})\s*(\d+)\s*(#{REG_OU})?\s*$/i
   # 属性・ステートリスト
   #  ステート 1,-2,3  など
   COOPERATE_ARRAYS = /^\s*(#{REG_NAME})\s*(\d+(?:\s*,\s*\-?\d+)*)\s*$/i
end
  end
end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ RPG::Skill
#==============================================================================

class RPG::Skill < RPG::UsableItem
  #--------------------------------------------------------------------------
  # ○ 連係スキルであるか
  #--------------------------------------------------------------------------
  def is_cooperation?
self.note.each_line { |line|
   # 開始タグを探す
   if line =~ KGC::CooperationSkill::Regexp::Skill::BEGIN_COOPERATE
      return true
   end
}
return false
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Game_Temp
#==============================================================================

class Game_Temp
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :judging_cooperation_skill # 連係スキル判定中フラグ
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  alias initialize_KGC_CooperationSkill initialize
  def initialize
initialize_KGC_CooperationSkill

@judging_cooperation_skill = false
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# □ Game_CooperationSkill
#------------------------------------------------------------------------------
# 連係スキルの情報を扱うクラスです。
#==============================================================================

class Game_CooperationSkill
  #--------------------------------------------------------------------------
  # ○ 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_reader :id                      # 発動スキル ID
  attr_reader :need_skills             # 必要スキル ID リスト
  attr_reader :params                # 条件パラメータ
  attr_reader :params_over             # 条件パラメータ: ～以上
  attr_reader :need_arrays             # 必要属性・ステートリスト
  attr_reader :disuse_arrays          # 不要属性・ステートリスト
  #--------------------------------------------------------------------------
  # ○ オブジェクト初期化
  #    skill_id : スキル ID
  #    note    : メモ
  #--------------------------------------------------------------------------
  def initialize(skill_id, note)
@id          = skill_id
@need_skills = []
@params       = {}
@params_over = {}
@need_arrays = {}
@disuse_arrays = {}
parse_note(note)
  end
  #--------------------------------------------------------------------------
  # ○ スキルを取得
  #--------------------------------------------------------------------------
  def skill
return $data_skills[@id]
  end
  #--------------------------------------------------------------------------
  # ○ メモ欄を解析
  #    note : メモ
  #--------------------------------------------------------------------------
  def parse_note(note)
coop_flag = false
note.each_line { |line|
   case line
   when KGC::CooperationSkill::Regexp::Skill::BEGIN_COOPERATE
      # 連係スキル定義開始
      coop_flag = true
   when KGC::CooperationSkill::Regexp::Skill::END_COOPERATE
      # 連係スキル定義終了
      coop_flag = false
   end
   next unless coop_flag

   case line
   when KGC::CooperationSkill::Regexp::Skill::NEED_SKILLS
      # 必要スキル
      parse_need_skills($1.scan(/\-?\d+/))
   when KGC::CooperationSkill::Regexp::Skill::COOPERATE_PARAMS
      # パラメータ
      parse_params($1, $2.to_i, $3)
   when KGC::CooperationSkill::Regexp::Skill::COOPERATE_ARRAYS
      # 属性・ステート
      parse_arrays($1, $2.scan(/\-?\d+/))
   end
}
  end
  #--------------------------------------------------------------------------
  # ○ 必要スキルを解析
  #    list  : スキル ID 一覧
  #--------------------------------------------------------------------------
  def parse_need_skills(list)
skills = []
list.each { |num|
   skills << num.to_i
}
@need_skills << skills
  end
  #--------------------------------------------------------------------------
  # ○ 連係スキルの能力値修正を適用
  #    param : 対象パラメータ
  #    value : 修正値
  #    cond  : 以上 or 以下
  #--------------------------------------------------------------------------
  def parse_params(param, value, cond)
KGC::CooperationSkill::PARAMS.each { |k, v|
   next if param !~ /(?:#{v})/i

   @params[k]    = value
   @params_over[k] = (cond !~ /UNDER|以下/i)
   break
}
  end
  #--------------------------------------------------------------------------
  # ○ 連係スキルの追加属性・ステートを適用
  #    param : 対象パラメータ
  #    list  : 属性・ステート一覧
  #--------------------------------------------------------------------------
  def parse_arrays(param, list)
KGC::CooperationSkill::ARRAYS.each { |k, v|
   next if param !~ /(?:#{v})/i

   if @need_arrays[k] == nil
      @need_arrays[k] = []
      @disuse_arrays[k] = []
   end
   list.each { |num|
      n = num.to_i
      if n > 0
      @need_arrays[k] |= [n]
      else
      @disuse_arrays[k] |= [n.abs]
      end
   }
   break
}
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

$data_skills = load_data("Data/Skills.rvdata") if $data_skill == nil

module KGC::CooperationSkill
  # 連係スキルリストを変換
  list = []
  $data_skills.each { |skill|
next if skill == nil
next unless skill.is_cooperation?

list << Game_CooperationSkill.new(skill.id, skill.note)
  }
  SKILLS = list
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Game_Actor
#==============================================================================

class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # ● スキルの使用可能判定
  #    skill : スキル
  #--------------------------------------------------------------------------
  def skill_can_use?(skill)
return super
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# □ Game_CooperationSkillUser
#------------------------------------------------------------------------------
# 連係スキル発動者の情報を扱うクラスです。
#==============================================================================

class Game_CooperationSkillUser
  #--------------------------------------------------------------------------
  # ○ 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_reader :index                   # 発動者のインデックス
  attr_reader :skill_id                # 発動者が使用したスキル ID
  attr_reader :target_battlers       # 攻撃対象
  #--------------------------------------------------------------------------
  # ○ オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(battler)
if $imported["Counter"]
   battler.action.made_targets = nil
end
@index = battler.index
@skill_id = battler.action.skill_id
@target_battlers = []
battler.action.make_targets.each { |t|
   @target_battlers << t.index
}
  end
  #--------------------------------------------------------------------------
  # ○ 同値判定
  #--------------------------------------------------------------------------
  def equal?(obj)
return false unless obj.is_a?(Game_CooperationSkillUser)
return false if @index != obj.index
return false if @skill_id != obj.skill_id
return false if @target_battlers != obj.target_battlers

return true
  end
  #--------------------------------------------------------------------------
  # ○ 等値演算子
  #--------------------------------------------------------------------------
  def ==(obj)
return self.equal?(obj)
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# □ Game_CooperationBattler
#------------------------------------------------------------------------------
# 連係スキル発動時のダミーバトラークラスです。
#==============================================================================

class Game_CooperationBattler < Game_Battler
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :battler_type          # :actor or :enemy
  attr_accessor :exec_battlers          # 発動者リスト
  attr_accessor :coop_skill             # 連係スキル情報
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize
@battler_type  = :actor
@exec_battlers = []
@coop_skill = nil
super
  end
  #--------------------------------------------------------------------------
  # ● アクターか否かの判定
  #--------------------------------------------------------------------------
  def actor?
return (@battler_type == :actor)
  end
  #--------------------------------------------------------------------------
  # ● インデックス取得
  #--------------------------------------------------------------------------
  def index
return 0
  end
  #--------------------------------------------------------------------------
  # ● 表示名の取得
  #--------------------------------------------------------------------------
  def name
str = ""
members = (actor? ? $game_party : $game_troop).members
exec_battlers.each_with_index { |b, i|
   str += members[b.index].name
   if i < exec_battlers.size - 1
      str += KGC::CooperationSkill::NAME_SEPARATOR
   end
}
return str
  end
  #--------------------------------------------------------------------------
  # ● レベルの取得
  #--------------------------------------------------------------------------
  def level
values = []
exec_battlers.each { |b| values << b.level }
return values.max
  end
  #--------------------------------------------------------------------------
  # ○ 最大レベルの取得
  #--------------------------------------------------------------------------
  def level_max
return level
  end
  #--------------------------------------------------------------------------
  # ○ 平均レベルの取得
  #--------------------------------------------------------------------------
  def level_avg
n = 0
exec_battlers.each { |b| n += b.level }
return (n / exec_battlers.size)
  end
  #--------------------------------------------------------------------------
  # ● MaxHP の取得
  #--------------------------------------------------------------------------
  def maxhp
values = []
exec_battlers.each { |b| values << b.maxhp }
return values.max
  end
  #--------------------------------------------------------------------------
  # ● MaxMP の取得
  #--------------------------------------------------------------------------
  def maxmp
values = []
exec_battlers.each { |b| values << b.maxmp }
return values.max
  end
  #--------------------------------------------------------------------------
  # ● HP の取得
  #--------------------------------------------------------------------------
  def hp
values = []
exec_battlers.each { |b| values << b.hp }
return values.min
  end
  #--------------------------------------------------------------------------
  # ● MP の取得
  #--------------------------------------------------------------------------
  def mp
values = []
exec_battlers.each { |b| values << b.mp }
return values.min
  end
  #--------------------------------------------------------------------------
  # ○ ドライブゲージ量取得
  #--------------------------------------------------------------------------
  def overdrive
values = []
exec_battlers.each { |b| values << b.overdrive }
return values.min
  end
  #--------------------------------------------------------------------------
  # ● 攻撃力の取得
  #--------------------------------------------------------------------------
  def atk
values = []
exec_battlers.each { |b| values << b.atk }
return values.max
  end
  #--------------------------------------------------------------------------
  # ● 防御力の取得
  #--------------------------------------------------------------------------
  def def
values = []
exec_battlers.each { |b| values << b.def }
return values.max
  end
  #--------------------------------------------------------------------------
  # ● 精神力の取得
  #--------------------------------------------------------------------------
  def spi
values = []
exec_battlers.each { |b| values << b.spi }
return values.max
  end
  #--------------------------------------------------------------------------
  # ● 敏捷性の取得
  #--------------------------------------------------------------------------
  def agi
values = []
exec_battlers.each { |b| values << b.agi }
return values.max
  end
  #--------------------------------------------------------------------------
  # ● 命中率の取得
  #--------------------------------------------------------------------------
  def hit
values = []
exec_battlers.each { |b| values << b.hit }
return [values.max, 100].max
  end
  #--------------------------------------------------------------------------
  # ● 回避率の取得
  #--------------------------------------------------------------------------
  def eva
return 0
  end
  #--------------------------------------------------------------------------
  # ● クリティカル率の取得
  #--------------------------------------------------------------------------
  def cri
values = []
exec_battlers.each { |b| values << b.cri }
return values.max
  end
  #--------------------------------------------------------------------------
  # ● MP の変更
  #    mp : 新しい MP
  #--------------------------------------------------------------------------
  def mp=(mp)
# 加担者全員の MP を減らす
diff = self.mp - mp
exec_battlers.each { |b| b.mp -= diff }
  end
  #--------------------------------------------------------------------------
  # ○ ドライブゲージの操作
  #--------------------------------------------------------------------------
  def overdrive=(value)
# 加担者全員のドライブゲージを減らす
diff = self.overdrive - overdrive
exec_battlers.each { |b| b.overdrive -= diff }
  end
  #--------------------------------------------------------------------------
  # ● 全回復
  #--------------------------------------------------------------------------
  def recover_all
# 何もしない
  end
  #--------------------------------------------------------------------------
  # ● 戦闘不能判定
  #--------------------------------------------------------------------------
  def dead?
exec_battlers.each { |b|
   return true if b.dead?
}
return false
  end
  #--------------------------------------------------------------------------
  # ● 存在判定
  #--------------------------------------------------------------------------
  def exist?
exec_battlers.each { |b|
   return false unless b.exist?
}
return true
  end
  #--------------------------------------------------------------------------
  # ● コマンド入力可能判定
  #--------------------------------------------------------------------------
  def inputable?
exec_battlers.each { |b|
   return false unless b.inputtable?
}
return true
  end
  #--------------------------------------------------------------------------
  # ● 行動可能判定
  #--------------------------------------------------------------------------
  def movable?
exec_battlers.each { |b|
   return false unless b.movable?
}
return true
  end
  #--------------------------------------------------------------------------
  # ● 沈黙状態判定
  #--------------------------------------------------------------------------
  def silent?
exec_battlers.each { |b|
   return true if b.silent?
}
return false
  end
  #--------------------------------------------------------------------------
  # ● 暴走状態判定
  #--------------------------------------------------------------------------
  def berserker?
return false
  end
  #--------------------------------------------------------------------------
  # ● 混乱状態判定
  #--------------------------------------------------------------------------
  def confusion?
return false
  end
  #--------------------------------------------------------------------------
  # ● 防御中判定
  #--------------------------------------------------------------------------
  def guarding?
return false
  end
  #--------------------------------------------------------------------------
  # ● 通常攻撃の属性取得
  #--------------------------------------------------------------------------
  def element_set
result = []
exec_battlers.each { |b| result |= b.element_set }
return result
  end
  #--------------------------------------------------------------------------
  # ● 通常攻撃のステート変化 (+) 取得
  #--------------------------------------------------------------------------
  def plus_state_set
result = []
exec_battlers.each { |b| result |= b.plus_state_set }
return result
  end
  #--------------------------------------------------------------------------
  # ● 通常攻撃のステート変化 (-) 取得
  #--------------------------------------------------------------------------
  def minus_state_set
result = []
exec_battlers.each { |b| result |= b.minus_state_set }
return result
  end
  #--------------------------------------------------------------------------
  # ● ステート [スリップダメージ] 判定
  #--------------------------------------------------------------------------
  def slip_damage?
return false
  end
  #--------------------------------------------------------------------------
  # ● ステート [命中率減少] 判定
  #--------------------------------------------------------------------------
  def reduce_hit_ratio?
return false
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Scene_Battle
#==============================================================================

class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  # ● 開始処理
  #--------------------------------------------------------------------------
  alias start_KGC_CooperationSkill start
  def start
start_KGC_CooperationSkill

init_cooperation_skill
  end
  #--------------------------------------------------------------------------
  # ○ 連係スキル用変数初期化
  #--------------------------------------------------------------------------
  def init_cooperation_skill
@cooperation_skill_judged = false
@cooperation_skill_exec = false
@cooperation_skill_data = nil
@cooperate_actors  = []
@cooperate_enemies = []
  end
  #--------------------------------------------------------------------------
  # ● パーティコマンド選択の開始
  #--------------------------------------------------------------------------
  alias start_party_command_selection_KGC_CooperationSkill
start_party_command_selection
  def start_party_command_selection
if $game_temp.in_battle
   init_cooperation_skill
end

start_party_command_selection_KGC_CooperationSkill
  end
  #--------------------------------------------------------------------------
  # ● 戦闘処理の実行開始
  #--------------------------------------------------------------------------
  alias start_main_KGC_CooperationSkill start_main
  def start_main
start_main_KGC_CooperationSkill

init_cooperate_battler_list
  end
  #--------------------------------------------------------------------------
  # ○ 判定用データ初期化
  #--------------------------------------------------------------------------
  def init_cooperate_battler_list
[:actor, :enemy].each { |i|
   case i
   when :actor
      cooperate_battlers = @cooperate_actors
      members = $game_party.members
   when :enemy
      cooperate_battlers = @cooperate_enemies
      members = $game_troop.members
   end
   # 対象側バトラーを設定
   cooperate_battlers.clear
   unless KGC::CooperationSkill::EXECUTE_ORIGIN_SKILL
      members.each { |battler|
      next unless battler.action.skill?
      cooperate_battlers << Game_CooperationSkillUser.new(battler)
      }
   end
}
  end
  #--------------------------------------------------------------------------
  # ● 戦闘行動の実行
  #--------------------------------------------------------------------------
  alias execute_action_KGC_CooperationSkill execute_action
  def execute_action
@cooperation_skill_judged = false

if KGC::CooperationSkill::EXECUTE_ORIGIN_SKILL
   execute_action_KGC_CooperationSkill
   judge_cooperation_skill(@active_battler)
else
   judge_cooperation_skill(@active_battler)
   unless @cooperation_skill_judged && @cooperation_skill_exec
      execute_action_KGC_CooperationSkill
   end
end

if @cooperation_skill_exec
   if @cooperation_skill_judged
      execute_cooperation_skill
   else
      finish_cooperation_skill
   end
end
  end
  #--------------------------------------------------------------------------
  # ○ 連係スキル第一発動判定
  #    battler : 行動者
  #--------------------------------------------------------------------------
  def judge_cooperation_skill(battler)
return false if @cooperation_skill_judged
return false if @cooperation_skill_exec
@cooperation_skill_judged = true

target_unit = (battler.is_a?(Game_Actor) ? $game_troop : $game_party)
if battler.action.kind == 1
   # 対象が残っていれば第二発動判定
   unless target_unit.all_dead?
      return judge_cooperation_skill_second(battler)
   end
else
   # 行動がスキル以外なら判定用配列から削除
   if target_unit.is_a?(Game_Party)
      remove_cooperate_battler(:enemy, battler)
   elsif target_unit.is_a?(Game_Troop)
      remove_cooperate_battler(:actor, battler)
   end
end
return false
  end
  #--------------------------------------------------------------------------
  # ○ 連係加担者削除
  #    type : :actor or :enemy
  #    battler : 削除対象
  #--------------------------------------------------------------------------
  def remove_cooperate_battler(type, battler)
battlers = (type == :actor ? @cooperate_actors : @cooperate_enemies)
battlers.each_index { |i|
   if battlers.index == battler.index
      battlers = nil
   end
}
battlers.compact!
  end
  #--------------------------------------------------------------------------
  # ○ 連係スキル第二発動判定
  #    battler : 行動者
  #--------------------------------------------------------------------------
  def judge_cooperation_skill_second(battler)
# 判定用データ作成
@current_cooperate_user = Game_CooperationSkillUser.new(battler)
if battler.is_a?(Game_Actor)
   remove_cooperate_battler(:actor, battler)
   @cooperate_actors |= [@current_cooperate_user]
elsif battler.is_a?(Game_Enemy)
   remove_cooperate_battler(:enemy, battler)
   @cooperate_enemies |= [@current_cooperate_user]
end
# 連係スキル発動判定
KGC::CooperationSkill::SKILLS.each { |cs|
   # アクター判定
   if battler.is_a?(Game_Actor)
      judge_cooperation_skill_third(:actor, cs)
   # エネミー判定
   elsif battler.is_a?(Game_Enemy)
      judge_cooperation_skill_third(:enemy, cs)
   end

   break if @cooperation_skill_exec
}
return @cooperation_skill_exec
  end
  #--------------------------------------------------------------------------
  # ○ 連係スキル第三発動判定
  #    type : :actor or :enemy
  #    cs_data : Cooperation skill data
  #--------------------------------------------------------------------------
  def judge_cooperation_skill_third(type, cs_data)
if type == :enemy
   # エネミーに発動させない場合は戻る
   return unless KGC::CooperationSkill::PERMIT_ENEMY
end

@cooperation_skill_exec = false
case type
when :actor
   cooperate_battlers = @cooperate_actors
   members = $game_party.members
when :enemy
   cooperate_battlers = @cooperate_enemies
   members = $game_troop.members
end

@exec_battlers = create_cooperation_exec_battlers(type, cs_data,
   cooperate_battlers, members)
# 行動者が加担していなければ戻る
return if @exec_battlers.empty?

# 同一ターゲットを指定していなければ戻る
return unless same_target_include?(cs_data, cooperate_battlers, members)

$game_temp.judging_cooperation_skill = true
prepare_cooperation_exec(type, cs_data, cooperate_battlers, members)
$game_temp.judging_cooperation_skill = false
  end
  #--------------------------------------------------------------------------
  # ○ 連係スキル発動者リスト作成
  #    type             : :actor or :enemy
  #    cs_data          : Cooperation skill data
  #    cooperate_battlers : 連係加担者リスト
  #    members          : 連係加担側のメンバー全体
  #--------------------------------------------------------------------------
  def create_cooperation_exec_battlers(type, cs_data,
   cooperate_battlers, members)
battlers = []
cs_data.need_skills.each { |ns|
   battlers.clear
   # 行動者加担判定
   next unless ns.include?(@current_cooperate_user.skill_id)

   # 全必要スキル充足判定
   skills = ns.clone
   ns.each { |skill_id|
      user = cooperate_battlers.find { |cb|
      skill_id == cb.skill_id && !battlers.include?(cb)
      }
      # 使用者がいなければ失敗判定
      if user == nil
      battlers.clear
      skills = [0]
      break
      end
      battlers << user
      skills.delete(skill_id)
   }
   break if skills.empty?  # 判定用配列が空 ==> 必要スキル充足
}

unless cooperation_conditions_satisfy?(type, cs_data, battlers, members)
   battlers = []
end

return battlers
  end
  #--------------------------------------------------------------------------
  # ○ 使用条件充足判定
  #    type             : :actor or :enemy
  #    cs_data          : Cooperation skill data
  #    candidate_battlers : 判定対象の連係加担者リスト
  #    members          : 連係加担側のメンバー全体
  #--------------------------------------------------------------------------
  def cooperation_conditions_satisfy?(type, cs_data,
   candidate_battlers, members)
return false if candidate_battlers.empty?
return true  if type == :enemy

# パラメータ算出
level_avg = 0
levels = []
candidate_battlers.each { |cb|
   battler = members[cb.index]
   level_avg += battler.level
   levels << battler.level
}
level_avg /= members.size

comp = Proc.new { |a, b, over| over ? a >= b : a <= b }  # 判定用 Proc

cs_data.params.each { |k, v|
   param = 0
   case k
   when :level_avg  # 平均レベル
      param = level_avg
   when :level_min  # 最低レベル
      param = levels.min
   when :level_max  # 最高レベル
      param = levels.max
   end
   return false unless comp.call(param, v, cs_data.params_over[k])
}

return true
  end
  #--------------------------------------------------------------------------
  # ○ 連係ターゲット一致判定
  #    cs_data          : Cooperation skill data
  #    cooperate_battlers : 連係加担者リスト
  #    members          : 連係加担側のメンバー全体
  #--------------------------------------------------------------------------
  def same_target_include?(cs_data, cooperate_battlers, members)
return true unless KGC::CooperationSkill::SAME_TARGET_ONLY

# 同じターゲットを指定しているか判定
duplicate_battlers = (0..99).to_a
@exec_battlers.each { |eb|
   duplicate_battlers &= eb.target_battlers
}
return (duplicate_battlers.size > 0)
  end
  #--------------------------------------------------------------------------
  # ○ 連係発動準備
  #    type             : :actor or :enemy
  #    cs_data          : Cooperation skill data
  #    cooperate_battlers : 連係加担者リスト
  #    members          : 連係加担側のメンバー全体
  #--------------------------------------------------------------------------
  def prepare_cooperation_exec(type, cs_data, cooperate_battlers, members)
# 発動可否判定
@exec_battlers.each { |eb|
   battler = members[eb.index]
   unless battler.exist? && battler.skill_can_use?(cs_data.skill)
      return
   end
}

@cooperation_skill_exec = true
@cooperation_skill_data = cs_data
@cooperation_skill_user = type

# 発動者を行動順リストから削除
cooperate_battlers.each_with_index { |cb, i|
   if @exec_battlers.include?(cb)
      @action_battlers.delete(members[cb.index])
      cooperate_battlers = nil
   end
}
cooperate_battlers.compact!
  end
  #--------------------------------------------------------------------------
  # ○ 連係スキル発動
  #--------------------------------------------------------------------------
  def execute_cooperation_skill
# ダミーを登録
@action_battlers.unshift(create_cooperation_skill_battler)
  end
  #--------------------------------------------------------------------------
  # ○ 連係発動者 (ダミーバトラー) 作成
  #--------------------------------------------------------------------------
  def create_cooperation_skill_battler
battler = Game_CooperationBattler.new
battler.battler_type = @cooperation_skill_user
battler.coop_skill = @cooperation_skill_data
battler.action.set_skill(@cooperation_skill_data.id)

# ターゲット取得
members = (@cooperation_skill_user == :actor ?
   $game_party : $game_troop).members
target = (0..99).to_a
@exec_battlers.each { |eb|
   battler.exec_battlers << members[eb.index]
   target &= eb.target_battlers
}
if target.empty?
   # ターゲット不明なら最後の行動者のターゲットを採用
   target = @current_cooperate_user.target_battlers
end
battler.action.target_index = target[rand(target.size)]

return battler
  end
  #--------------------------------------------------------------------------
  # ○ 連係スキル終了
  #--------------------------------------------------------------------------
  def finish_cooperation_skill
@cooperation_skill_exec = false
@cooperation_skill_data = nil
@exec_battlers       = []
  end
  #--------------------------------------------------------------------------
  # ○ 連係スキル加担判定
  #    battler : 判定するバトラー
  #--------------------------------------------------------------------------
  def cooperation_exec?(battler)
return false unless @cooperation_skill_exec

if battler.is_a?(Game_Actor) || KGC::CooperationSkill::PERMIT_ENEMY
   # 発動者に含まれているか判定
   @exec_battlers.each_index { |i|
      return true if @exec_battlers.index == battler.index
   }
end
return false
  end
end

不過這是VX版本
想用在VA上的話，是否需要更改一些地方？

麻煩你了，謝謝

vince3725 · 发表于 2012-10-27 18:36:16

本帖最后由 vince3725 于 2012-10-27 18:43 编辑

先制 #==============================================================================
# ■ 先制スイッチ1
# @version 0.1 12/01/22
# @author さば缶
#------------------------------------------------------------------------------
# 戦闘の先制、不意打ちをスイッチで制御します
#==============================================================================
module Saba
  module Preemptive
PREEMPTIVE_SWITCH = 0  # このスイッチがONだと先制
SURPRISE_SWITCH = 0 # このスイッチがONだと不意打ち
  end
end

class << BattleManager
  include Saba::Preemptive
  #--------------------------------------------------------------------------
  # ● セットアップ
  #--------------------------------------------------------------------------
  alias saba_preemptive_setup setup
  def setup(troop_id, can_escape = true, can_lose = false)
saba_preemptive_setup(troop_id, can_escape, can_lose)
setup_preemptive_switch
  end
  #--------------------------------------------------------------------------
  # ● エンカウント時の処理
  #--------------------------------------------------------------------------
  alias saba_preemptive_on_encounter on_encounter
  def on_encounter
saba_preemptive_on_encounter
setup_preemptive_switch
  end
  #--------------------------------------------------------------------------
  # ○ スイッチによる先制、不意打ちの設定
  #--------------------------------------------------------------------------
  def setup_preemptive_switch
if $game_switches[PREEMPTIVE_SWITCH]
   @preemptive = true
   @surprise = false
elsif $game_switches[SURPRISE_SWITCH]
   @preemptive = false
   @surprise = true
end
  end
end

战斗顺序
#==============================================================================
# ■ 碧の軌跡っぽい戦闘システム13_3　OrderManager
# @version 0.23 12/01/28
# @author さば缶
#------------------------------------------------------------------------------
# 　順番を管理するモジュールが入っています
#==============================================================================
module OrderManager

  #--------------------------------------------------------------------------
  # ○ オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize
init_unit
  end
  #--------------------------------------------------------------------------
  # ○ 先頭のユニット取得
  #--------------------------------------------------------------------------
  def self.top_unit
return @top_unit
  end
  #--------------------------------------------------------------------------
  # ○ ユニット初期化
  #--------------------------------------------------------------------------
  def self.init_unit
@units = []
for actor in $game_party.battle_members
   next if actor.dead?
   if BattleManager.preemptive
      delay_time = $data_skills[153].operate_time(actor)
   else
      delay_time = $data_skills[154].operate_time(actor)
   end
   @units.push(Game_BattleUnit.new(actor, delay_time))
end
for enemy in $game_troop.members
   if BattleManager.surprise
      delay_time = $data_skills[153].operate_time(enemy)
   else
      delay_time = $data_skills[154].operate_time(enemy)
   end
   @units.push(Game_BattleUnit.new(enemy, delay_time)) if enemy.alive?
end
sort
update_top
init_position
  end
  #--------------------------------------------------------------------------
  # ○ 座標を初期化
  #--------------------------------------------------------------------------
  def self.init_position
@top_unit.init_position
@units.each { |unit| unit.init_position }
  end
  #--------------------------------------------------------------------------
  # ○ フレーム更新
  #--------------------------------------------------------------------------
  def self.update
check_alive
check_dead
self.units.each { |unit| unit.update }
  end
  #--------------------------------------------------------------------------
  # ○ バトラーの配列を返します。
  #--------------------------------------------------------------------------
  def self.battlers
@units.collect {|unit| unit.battler }.uniq
  end
  #--------------------------------------------------------------------------
  # ○ ユニットの点滅を停止します。
  #--------------------------------------------------------------------------
  def self.clear_blink
for unit in @units
   unit.blink = false
   unit.targeted = false
end
  end
  #--------------------------------------------------------------------------
  # ○ 指定のキャラの最小さいディレイコマ数を取得
  #--------------------------------------------------------------------------
  def self.min_delay_count(battler)
unit = find_unit(battler)
return [email protected](unit)
  end
  #--------------------------------------------------------------------------
  # ○ 指定のキャラの最大ディレイコマ数を取得
  #--------------------------------------------------------------------------
  def self.max_delay_count(battler)
unit = find_unit(battler)
return @units.size - @units.index(unit) - 1
  end
  #--------------------------------------------------------------------------
  # ○ 指定のキャラの待ち時間に指定の値を加えます。
  #--------------------------------------------------------------------------
  def self.add_delay(battler, delay)
unit = find_unit(battler)
return unless unit
unit.delay_time += delay if unit
sort
update_delay_time
  end
  #--------------------------------------------------------------------------
  # ○ 指定のキャラのスキル発動待ちをキャンセルします。
  #--------------------------------------------------------------------------
  def self.cancel(unit)
return false if unit == nil
unit.cancel
unit.delay_time = $data_skills[155].operate_time(unit.battler)
sort
update_delay_time
return true
  end
  #--------------------------------------------------------------------------
  # ○ 先頭ユニットを削除し、次のユニットに入れ替えます。
  #--------------------------------------------------------------------------
  def self.update_top
check_remove

old = @top_unit
@top_unit = @units[0]

@units.delete(@top_unit)
@top_unit.forecast = false
@top_unit.delay_time_decimal = 99
@units.each_with_index do |unit, i|
   unit.delay_time -= @top_unit.delay_time
   unit.forecast = false
end
@top_unit.delay_time = 0
update_delay_time
  end
  #--------------------------------------------------------------------------
  # ○ 指定のバトラーのユニットが存在するかを返します。
  #--------------------------------------------------------------------------
  def self.contains?(battler)
return find_unit(battler) != nil
  end
  #--------------------------------------------------------------------------
  # ○ ユニット内のキャラの死亡を判定します。
  #--------------------------------------------------------------------------
  def self.check_dead
for unit in @units.clone
   if  (unit.battler.dead? || unit.battler.hidden?)
      remove(unit.battler)
      next
   end
end
  end
  #--------------------------------------------------------------------------
  # ○ ユニット内の死亡したキャラの復活を判定します。
  #--------------------------------------------------------------------------
  def self.check_alive
for actor in $game_party.battle_members
   next if actor.dead?
   if find_unit(actor) == nil
      insert(actor, $data_skills[156].operate_time(actor))
   end
end
for actor in $game_troop.members
   next if actor.dead? || actor.hidden?
   if find_unit(actor) == nil
      insert(actor, $data_skills[156].operate_time(actor))
   end
end
  end
  #--------------------------------------------------------------------------
  # ○ ユニット内のパーティー抜けを判定します。
  #--------------------------------------------------------------------------
  def self.check_remove
for unit in @units.clone
   if unit.battler.actor?
      unless $game_party.battle_members.include?(unit.battler)
      remove(unit.battler)
      next
      end
   end
end
  end
  #--------------------------------------------------------------------------
  # ○ 指定のバトラーをユニットとして追加します。
  #  battler 追加するバトラー
  #  delay_time 待ち時間
  #  forecast 行動順の予想ユニットかどうかのフラグ
  #  item 待ち時間が必要なアイテム
  #--------------------------------------------------------------------------
  def self.insert(battler, delay_time, forecast = false, item = nil, operate = false)
delay_time = delay_time.round
unit = find_not_top_unit(battler)
if unit
   update_unit(unit, delay_time, forecast, item, operate)
else
   insert_new_unit(battler, delay_time, forecast, item, operate)
end
sort
update_delay_time
  end
  #--------------------------------------------------------------------------
  # ○ ユニットの状態を更新
  #--------------------------------------------------------------------------
  def self.update_unit(unit, delay_time, forecast, item, operate)
index = @units.index(unit)
if forecast
   unit.delay_time = delay_time
end
unit.forecast = forecast
unit.usable_item = item
unit.operate = operate
  end
  #--------------------------------------------------------------------------
  # ○ 新しいユニットを追加
  #--------------------------------------------------------------------------
  def self.insert_new_unit(battler, delay_time, forecast, item, operate)
new_unit = Game_BattleUnit.new(battler, delay_time, forecast, item, operate)
new_unit.x = Saba::Kiseki::INSERT_DISTANCE
@units.push(new_unit)
  end
  #--------------------------------------------------------------------------
  # ○ 待ち時間を更新
  #--------------------------------------------------------------------------
  def self.update_delay_time
@top_unit.index = 0 if @top_unit != nil
@units.each_with_index do |unit, i|
   unit.index = i + 1
   unit.delay_time_decimal = i * 500 # 間にディレイキャラを差し込むため
end
  end
  #--------------------------------------------------------------------------
  # ○ 先頭以外で指定のバトラーを内部に持つユニットを検索します。
  #--------------------------------------------------------------------------
  def self.find_not_top_unit(battler)
return @units.reverse.select { |unit| unit.battler == battler}[0]
  end
  #--------------------------------------------------------------------------
  # ○ 指定のバトラーを内部に持つユニットを検索します。
  #--------------------------------------------------------------------------
  def self.find_unit(battler)
return self.units.reverse.select { |unit| unit.battler == battler}[0]
  end
  #--------------------------------------------------------------------------
  # ○ 指定のバトラーを内部に持つユニットを削除します。
  #--------------------------------------------------------------------------
  def self.remove(battler)
unit = find_unit(battler)
return if unit == nil
@units.delete(unit)
  end
  #--------------------------------------------------------------------------
  # ○ 全てのユニットを返します。
  #--------------------------------------------------------------------------
  def self.units
return ([@top_unit] + @units).compact
  end
  #--------------------------------------------------------------------------
  # ○ 全てのユニットを行動順に並び替えます。
  #--------------------------------------------------------------------------
  def self.sort
@units.sort! { |a, b| a.delay_time_compare <=> b.delay_time_compare }
  end
  #--------------------------------------------------------------------------
  # ○ 指定のバトラーを含むユニットを点滅
  #--------------------------------------------------------------------------
  def self.blink(battler, show_targeted = true)
unit = find_unit(battler)
return if unit == nil
unit.blink = true
show_target(battler) if show_targeted
  end
  #--------------------------------------------------------------------------
  # ○ 指定のバトラーの攻撃目標を表示
  #--------------------------------------------------------------------------
  def self.show_target(battler)
for unit in @units.reverse
   unit.targeted = battler.target?(unit.battler)
end
  end
  #--------------------------------------------------------------------------
  # ○ 指定のバトラーの順番を遅らせる。
  #--------------------------------------------------------------------------
  def self.delay_order(battler, value)
unit = find_unit(battler)

return unless unit

if value > 0
   target = find_next_unit(unit, value)
   unit.delay_time_decimal = target.delay_time_decimal + 1 + unit.delay_time_decimal / 500
   unit.delay_time = target.delay_time
else
   target = find_prev_unit(unit, value)
   return if target == nil
   unit.delay_time = target.delay_time
   unit.delay_time_decimal = target.delay_time_decimal - 1
end
sort
  end
  #--------------------------------------------------------------------------
  # ○ 指定のユニットのvalue後ろのユニットを返す
  # 返されるユニットは delay_count が 0 のものに限る
  #--------------------------------------------------------------------------
  def self.find_next_unit(unit, value)
index = @units.index(unit) + value
begin
   target = @units[index]
   index += 1
   return last_unit if target == nil
end while target.battler.result.delay_count != 0
return target
  end
  #--------------------------------------------------------------------------
  # ○ 指定のユニットのvalue前のユニットを返す
  # 返されるユニットは delay_count が 0 のものに限る
  #--------------------------------------------------------------------------
  def self.find_prev_unit(unit, value)
index = @units.index(unit) + value
begin
   return top_unit if index < 0
   target = @units[index]
   index -= 1
   return top_unit if target == nil
end while target.battler.result.delay_count != 0
return target
  end
  #--------------------------------------------------------------------------
  # ○ 行動予想のマークを削除
  #--------------------------------------------------------------------------
  def self.clear_forecast
@units.each {|unit| unit.forecast = false }
  end
  #--------------------------------------------------------------------------
  # ○ 行動予想のユニットを返す
  #--------------------------------------------------------------------------
  def self.forecast_unit
@units.each {|unit| return unit if unit.forecast }
return nil
  end
  #--------------------------------------------------------------------------
  # ○ 行動予想のユニットを削除
  #--------------------------------------------------------------------------
  def self.remove_forecast_unit
@units.delete_if {|unit| unit.forecast }
update_delay_time
  end
  #--------------------------------------------------------------------------
  # ○ 指定のユニットを選択
  #--------------------------------------------------------------------------
  def self.select(battler)
clear_selection
return unless find_unit(battler)
find_unit(battler).selected = true
show_targeted(battler)
  end
  #--------------------------------------------------------------------------
  # ○ 攻撃対象のユニットを表示
  #--------------------------------------------------------------------------
  def self.show_targeted(battler)
return if battler.actor?
unit = find_unit(battler)
return unless unit
unit.targets.each do |b|
   next unless find_unit(b)
   find_unit(b).targeted = true
end
  end
  #--------------------------------------------------------------------------
  # ○ 選択状態をクリア
  #--------------------------------------------------------------------------
  def self.clear_selection
@top_unit.selected = false
@top_unit.targeted = false
@units.each {|unit| unit.selected = false; unit.targeted = false }
  end
  #--------------------------------------------------------------------------
  # ○ 一番最後のユニットを返します。
  #--------------------------------------------------------------------------
  def self.last_unit
return @units[-1]
  end
end

表示系
#==============================================================================
# ■ 碧の軌跡っぽい戦闘システム13_2　表示系
# @version 0.22 12/01/27
# @author さば缶
#------------------------------------------------------------------------------
# 　表示部分をカスタムしたい場合はここをいじってください
#==============================================================================
module Saba
  module Kiseki
# 左の隙間
MARGIN_LEFT = 10

# 上の隙間
MARGIN_TOP = 10

# 先頭ユニットと２番目のユニットの隙間
MARGIN_CURRENT_BOTTOM = 10

# ユニット同士の y 方向の間隔
UNIT_INTERVAL = 32

# 新規ユニットが入るときの x 方向の移動距離
INSERT_DISTANCE = 32

# 行動するときのディレイ表示タイプ
# 0 文字で DELAY
# 1 時計アイコン
DELAY_DISPLAY_TYPE = 1

# 左の順番バーの高さ
ORDER_BAR_HEIGHT = 460

# キャンセルメッセージ
CANCEL_MSG       = "%sの%sはキャンセルされた！"
FAIL_CANCEL_MSG = "%sの%sをキャンセルできなかった！"
ANTI_CANCEL_MSG = "%sの%sはキャンセルできない！"

# ディレイメッセージ
DELAY_ENEMY_MSG =  "%sの行動を %s コマ遅らせた！"
DELAY_ACTOR_MSG =  "%sの行動が %s コマ遅れた！"
HASTE_ENEMY_MSG =  "%sの行動が %s コマ早まった！"
HASTE_ACTOR_MSG =  "%sの行動を %s コマ早めた！"
ANTI_DELAY_MSG    =  "%sの行動を遅らせられない！"
FAIL_DELAY_MSG    =  "%sの行動を遅らせられなかった！"
  end
end

#==============================================================================
# ■ Spriteset_BattleUnit
#------------------------------------------------------------------------------
# 　画面左の待ち時間バー上に表示するユニットです
#==============================================================================

class Spriteset_BattleUnit
  include Saba::Kiseki

  TARGET_ENEMY_COLOR = Color.new(255, 0, 0, 255)
  TARGET_ACTOR_COLOR = Color.new(0, 0, 255, 255)
  #--------------------------------------------------------------------------
  # ○ オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(viewport, unit)
super
@viewport = viewport
@unit = unit
@battler = unit.battler
@forecast = false

@layers = []

create_bg_layer
create_char_layer
create_char_select_layer
create_marker_layer
create_targeted_layer
create_arrow_layer
  end
  #--------------------------------------------------------------------------
  # ○ 背景レイヤの作成
  #--------------------------------------------------------------------------
  def create_bg_layer
@bg_layer = Sprite_Base.new(@viewport)
@bg_layer.bitmap = Bitmap.new(64, 64)
if @battler.actor?
   border = Cache.system("UnitBorder")
else
   border = Cache.system("UnitBorder2")
end
@bg_layer.bitmap.blt(0, 0, border, border.rect)
@bg_layer.z = 1

@layers.push(@bg_layer)
  end
  #--------------------------------------------------------------------------
  # ○ キャラレイヤの作成
  #--------------------------------------------------------------------------
  def create_char_layer
@char_layer = Sprite_Base.new(@viewport)
@char_layer.bitmap = Bitmap.new(32, 32)
@char_layer.z = 2
init_graphic
draw_character(@char_layer, @graphic_name, @graphic_index)
@layers.push(@char_layer)
  end
  #--------------------------------------------------------------------------
  # ○ キャラ選択レイヤの作成
  #--------------------------------------------------------------------------
  def create_char_select_layer
@char_select_layer = Sprite_Base.new(@viewport)
@char_select_layer.bitmap = Bitmap.new(32, 32)
@char_select_layer.z = 3
draw_character(@char_select_layer, @graphic_name, @graphic_index)
@char_select_layer.blend_type = 1
if @battler.actor?
   @char_select_layer.color = TARGET_ACTOR_COLOR
else
   @char_select_layer.color = TARGET_ENEMY_COLOR
end
@layers.push(@char_select_layer)
  end
  #--------------------------------------------------------------------------
  # ○ マーカーレイヤの作成
  #--------------------------------------------------------------------------
  def create_marker_layer
@marker_layer = Sprite_Base.new(@viewport)
@marker_layer.bitmap = Bitmap.new(32, 32)
@marker_layer.z = 4
marker = Cache.system("ActionMarker")
@marker_layer.bitmap.blt(0, 0, marker, marker.rect)
@marker_layer.visible = false
@layers.push(@marker_layer)
  end
  #--------------------------------------------------------------------------
  # ○ 駆動の対象レイヤの作成
  #--------------------------------------------------------------------------
  def create_targeted_layer
@targeted_layer = Sprite_Base.new(@viewport)
@targeted_layer.bitmap = Bitmap.new(32, 32)
@targeted_layer.z = 5
marker = Cache.system("Targeted")
@targeted_layer.bitmap.blt(0, 0, marker, marker.rect)
@targeted_layer.visible = false
@layers.push(@targeted_layer)
  end
  #--------------------------------------------------------------------------
  # ○ 矢印レイヤの作成
  #--------------------------------------------------------------------------
  def create_arrow_layer
@arrow_layer = Sprite_Base.new(@viewport)
@arrow_layer.bitmap = Bitmap.new(64, 32)
@arrow_layer.z = 6
arrow = Cache.system("ForecastArrow")
@arrow_layer.bitmap.blt(0, 0, arrow, arrow.rect)
@layers.push(@arrow_layer)

@arrow_index = 12
  end
  #--------------------------------------------------------------------------
  # ○ 解放
  #--------------------------------------------------------------------------
  def dispose
@layers.each do |layer|
   layer.bitmap.dispose
   layer.dispose
end

@forecast_sprite.dispose if @forecast_sprite
  end
  #--------------------------------------------------------------------------
  # ○ フレーム更新
  #--------------------------------------------------------------------------
  def update
x = @unit.x + MARGIN_LEFT
y = @unit.y + MARGIN_TOP

@layers.each do |layer|
   layer.x = x
   layer.y = y
   layer.update
end

@arrow_layer.x += @arrow_index
@arrow_layer.visible = @unit.forecast
@arrow_index -= 0.25
@arrow_index = 12 if @arrow_index == 0

@char_select_layer.visible = @unit.selected
@marker_layer.visible = @unit.operate
@targeted_layer.visible = @unit.targeted

update_forecast
update_opacity
  end
  #--------------------------------------------------------------------------
  # ○ 使用するグラフィックを決定します。
  #--------------------------------------------------------------------------
  def init_graphic
if @battler.actor?
   @graphic_name = @battler.character_name
   @graphic_index = @battler.character_index
else
   @graphic_name = enemy_graphic_name
   @graphic_index = enemy_graphic_index
end
  end
  #--------------------------------------------------------------------------
  # ○ 行動予測を更新
  #--------------------------------------------------------------------------
  def update_forecast
if @forecast_sprite
   @forecast_sprite.update
   @forecast_sprite.visible = BattleManager.phase == :input
end
return if @forecast == @unit.forecast

if @unit.forecast
   @forecast_sprite = Sprite_Forecast.new(@viewport, @unit)
else
   @forecast_sprite.dispose
   @forecast_sprite = nil
end
@forecast = @unit.forecast
  end
  #--------------------------------------------------------------------------
  # ○ キャラクターグラフィックを描画します。
  #--------------------------------------------------------------------------
  def draw_character(layer, character_name, character_index)
bitmap = Cache.character(character_name)
sign = character_name[/^[\!\$]./]
if sign && sign.include?('$')
   cw = bitmap.width / 3
   ch = bitmap.height / 4
else
   cw = bitmap.width / 12
   ch = bitmap.height / 8
end
n = character_index
src_rect = Rect.new((n%4*3+1)*cw, (n/4*4)*ch, cw, ch)
layer.bitmap.blt(0, 0, bitmap, src_rect)
  end
  #--------------------------------------------------------------------------
  # ○ 行動待ちマーカーを描画します。
  #--------------------------------------------------------------------------
  def draw_action_marker
bitmap = Cache.system("ActionMarker")
@char_layer.bitmap.blt(0, 0, bitmap, bitmap.rect)
  end
  #--------------------------------------------------------------------------
  # ○ 透明度を更新します。
  #--------------------------------------------------------------------------
  def update_opacity
opacity  = 255 - @unit.x * 8
@arrow_layer.opacity = opacity
@bg_layer.opacity = opacity
@char_layer.opacity  = opacity
@forecast_sprite.opacity = opacity if @forecast_sprite
  end
  #--------------------------------------------------------------------------
  # ○ バトラーが敵エネミーの場合、使用するグラフィック名を初期化します。
  #--------------------------------------------------------------------------
  def enemy_graphic_name
marker = Saba::Kiseki::GRAPHIC_MARKER
graphic = get_ex_value_with_index(@battler.enemy, marker, 0)
if graphic == nil
   return Saba::Kiseki::DEFAULT_MONSTER_GRAPHIC_NAME
else
   return graphic
end
  end
  #--------------------------------------------------------------------------
  # ○ バトラーが敵エネミーの場合、使用するグラフィック内のインデックスを初期化します。
  #--------------------------------------------------------------------------
  def enemy_graphic_index
marker = Saba::Kiseki::GRAPHIC_MARKER
index = get_ex_value_with_index(@battler.enemy, marker, 1)
if index == nil
   return Saba::Kiseki::DEFAULT_MONSTER_GRAPHIC_INDEX
else
   return index.to_i
end
  end
  def get_ex_value_with_index(item, name, index)
item.note.split(/[\r\n]+/).each do |line|
elements = line.split(/\s+/)
   next if elements.size <= index + 1
   next unless elements[0] == name
   return elements[index + 1]
end
return nil
  end
end

#==============================================================================
# ■ Sprite_Forecast
#------------------------------------------------------------------------------
# 　待ち時間表示です。Delay XX というあれ
#==============================================================================

class Sprite_Forecast < Sprite_Base
  include Saba::Kiseki
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(viewport, unit)
super(viewport)
@unit = unit
self.bitmap = Bitmap.new(120, 50)
@anime_index = 0
@wait_count = 0
refresh
update
self.z = 5
  end
  def refresh
self.bitmap.clear

if DELAY_DISPLAY_TYPE == 0
   delay = Cache.system("Delay")
   self.bitmap.font.size = 20
   self.bitmap.blt(0, 0, delay, delay.rect)
   self.bitmap.draw_text(41, 6, 58, 24, @unit.delay_time.to_s, 1)
else
   delay = Cache.system("Delay2")
   self.bitmap.font.size = 20
   self.bitmap.blt(0, 0, delay, delay.rect)
   clock = Cache.system("icon_clock")
   x = @anime_index % 4 * clock.width / 4
   y = @anime_index / 4 * clock.height / 2

   rect = Rect.new(x, y, clock.width / 4, clock.height / 2)
   self.bitmap.blt(3, 3, clock, rect)
   self.bitmap.draw_text(14, 5, 58, 22, @unit.delay_time.to_s, 1)
end
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  def dispose
self.bitmap.dispose
super
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
super
self.x = @unit.x + Saba::Kiseki::MARGIN_LEFT + 45
self.y = @unit.y + Saba::Kiseki::MARGIN_TOP
next_anime
  end
  def next_anime
@wait_count += 1
if @wait_count > 6
   @anime_index += 1
   @anime_index = 0 if @anime_index == 8
   @wait_count = 0
   refresh
end
  end
end

#==============================================================================
# ■ Spriteset_Kiseki
#------------------------------------------------------------------------------
# 　待ち時間バーの背景や、先頭キャラの枠など
#==============================================================================

class Spriteset_Kiseki
  include Saba::Kiseki
  #--------------------------------------------------------------------------
  # ○ オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(viewport)
super
@bg_layer = Sprite_Base.new(viewport)
@bg_layer.bitmap = Cache.system("OrderLine")
@bg_layer.z = 0
@bg_layer.x = 10
@bg_layer.src_rect.height = ORDER_BAR_HEIGHT

@window_layer = Sprite_Base.new(viewport)
@window_layer.bitmap = Cache.system("ActiveWindow")
@window_layer.z = 7
@window_layer.x = 2
@window_layer.y = 3
  end
  #--------------------------------------------------------------------------
  # ○ 解放
  #--------------------------------------------------------------------------
  def dispose
@bg_layer.dispose
@window_layer.dispose
  end
  #--------------------------------------------------------------------------
  # ○ フレーム更新
  #--------------------------------------------------------------------------
  def update
@bg_layer.update
@window_layer.update
  end
end

class Window_BattleLog
  include Saba::Kiseki
#--------------------------------------------------------------------------
  # ● 失敗の表示
  #--------------------------------------------------------------------------
  alias saba_kiseki_battle_display_failure display_failure
  def display_failure(target, item)
if target.result.hit? && !target.result.success
   saba_kiseki_battle_display_failure(target, item)
end
display_cancel(target, item)
display_delay(target, item)
  end
  #--------------------------------------------------------------------------
  # ○ アイテム準備の表示
  #--------------------------------------------------------------------------
  def display_prepare_item(target, item)
text = sprintf(target.name, item.name)
add_text(text)
wait
wait
wait
  end
  #--------------------------------------------------------------------------
  # ○ キャンセルの表示
  #--------------------------------------------------------------------------
  def display_cancel(target, item)
unit = OrderManager.find_unit(target)
return unless unit
usable_item = unit.usable_item
return if usable_item == nil
if target.result.cancel
   return unless CANCEL_MSG
   text = sprintf(CANCEL_MSG, target.name, usable_item.name)
   add_text(text)
   wait
elsif target.result.fail_cancel
   return unless FAIL_CANCEL_MSG
   text = sprintf(FAIL_CANCEL_MSG, target.name, usable_item.name)
   add_text(text)
   wait
elsif target.result.anti_cancel
   return unless ANTI_CANCEL_MSG
   text = sprintf(ANTI_CANCEL_MSG, target.name, usable_item.name)
   add_text(text)
   wait
end
  end
  #--------------------------------------------------------------------------
  # ○ ディレイの表示
  #--------------------------------------------------------------------------
  def display_delay(target, item)
delay = target.result.delay_count
if delay > 0
   if target.actor?
      return unless DELAY_ACTOR_MSG
      text = sprintf(DELAY_ACTOR_MSG, target.name, delay.to_s)
   else
      return unless DELAY_ENEMY_MSG
      text = sprintf(DELAY_ENEMY_MSG, target.name, delay.to_s)
   end
   add_text(text)
   wait
elsif delay < 0
   if target.actor?
      return unless HASTE_ACTOR_MSG
      text = sprintf(HASTE_ACTOR_MSG, target.name, delay.abs.to_s)
   else
      return unless HASTE_ENEMY_MSG
      text = sprintf(HASTE_ENEMY_MSG, target.name, delay.abs.to_s)
   end
   add_text(text)
   wait
elsif target.result.fail_delay
   return unless FAIL_DELAY_MSG
   text = sprintf(FAIL_DELAY_MSG, target.name)
   add_text(text)
   wait
elsif target.result.anti_delay
   return unless ANTI_DELAY_MSG
   text = sprintf(ANTI_DELAY_MSG, target.name)
   add_text(text)
   wait
end
  end
end


奖励
=begin
   ★ 碧の軌跡っぽい戦闘システム - ATボーナスプラグイン - ★

   碧の軌跡っぽい戦闘システムにATボーナス機能を追加します。
   ボーナスグラフィックは Graphics/System/ 配下に保存してください。

   ● ボーナス ●======================================================
   発生しうるボーナスは以下の9種類です
   --------------------------------------------------------------------
   行動開始時にHP 10 %回復
   --------------------------------------------------------------------
   行動開始時にHP 50 %回復
   --------------------------------------------------------------------
   行動開始時にMP 10 %回復
   --------------------------------------------------------------------
   行動開始時にMP 50 %回復
   --------------------------------------------------------------------
   行動開始時にTP 10 回復
   --------------------------------------------------------------------
   行動開始時にTP 50 回復
   --------------------------------------------------------------------
   クリティカル (ダメージもしくは回復量が 1.5倍)
   --------------------------------------------------------------------
   完全防御 (ダメージ0, 回復0, キャンセル無効, ステート変化無効, ディレイ無効)
   --------------------------------------------------------------------
   ラッシュ (2回続けて行動可能)
   ====================================================================

   ● お願い ●========================================================
   本スクリプトについて"碧の軌跡っぽい戦闘システム"の開発元である
   プチレア様及びさば缶様に問い合わせることのないようお願い致します。
   ====================================================================

   ※ 「碧の軌跡っぽい戦闘システム」は開発途中のようです。
      その為、本スクリプトの仕様は今後変更される可能性があります。

   ver0.11

   Last Update : 2012/01/24
   01/24 : クリティカルボーナス時にメッセージを表示できるように
   01/07 : 試験公開

   さば缶様 http://petitrare.com/blog/
   ろかん　　　http://kaisou-ryouiki.sakura.ne.jp/
=end

#===================================
#  ● 設定箇所
#===================================
module Rokan
module Kiseki_Plugin
  # 各ボーナスの発生しやすさを判断する変数番号
  BCV = 10

  #-----------------------------------------------------------------------------
  # 以下の形式で各ボーナスの発生しやすさを定義します。
  # 0が設定されたボーナスは発生しなくなります。(発生しやすさは相対評価です)
  #-----------------------------------------------------------------------------
  # 変数に格納されている値 =>
  # [ボーナスなし, HP10%回復, HP50%回復, MP10%回復,　MP50%回復,
  #                      TP10回復, TP50回復, クリティカル, 完全防御, ラッシュ],
  #-----------------------------------------------------------------------------
  BOP = {

-1 => [  1,  0,  0,  0,  0,  0,  0,  0,  0,  0],
   0 => [100,  5,  3,  5,  3,  5,  3,  2,  2,  2],
   1 => [ 90,  3,  0,  3,  0,  3,  0,  2,  0,  0],

   }

  # クリティカルボーナス時に表示されるメッセージ
  CriticalBonusText = "クリティカルボーナス！！"
end
end
#===================================
#  ここまで
#===================================

$rsi ||= {}
$rsi["空の軌跡_ATボーナス"] = true

class RPG::UsableItem
  #--------------------------------------------------------------------------
  # ● 駆動時間の取得
  #--------------------------------------------------------------------------
  alias _kiseki_bonus_operate_time operate_time
  def operate_time(battler)
if BonusManager.rash?
   0
else
   _kiseki_bonus_operate_time(battler)
end
  end
  #--------------------------------------------------------------------------
  # ● 硬直時間の取得
  #--------------------------------------------------------------------------
  alias _kiseki_bonus_stiff_time stiff_time
  def stiff_time(battler)
if BonusManager.rash?
   0
else
   _kiseki_bonus_stiff_time(battler)
end
  end
end

class << BattleManager
  #--------------------------------------------------------------------------
  # ● セットアップ
  #--------------------------------------------------------------------------
  alias _kiseki_bonus_setup setup
  def setup(troop_id, can_escape = true, can_lose = false)
_kiseki_bonus_setup(troop_id, can_escape, can_lose)
setup_bonus
  end
  #--------------------------------------------------------------------------
  # ● ボーナスのセットアップ
  #--------------------------------------------------------------------------
  def setup_bonus
BonusManager.clear
BonusManager.init_bonus
  end
end

class << OrderManager
  #--------------------------------------------------------------------------
  # ● 先頭ユニットを削除し、次のユニットに入れ替えます。
  #--------------------------------------------------------------------------
  alias _kiseki_bonus_update_top update_top
  def update_top
BonusManager.next_bonus
_kiseki_bonus_update_top
  end
  #--------------------------------------------------------------------------
  # ● 指定のバトラーの順番を遅らせる。
  #--------------------------------------------------------------------------
  alias _kiseki_bonus_delay_order delay_order
  def delay_order(battler, value)
_kiseki_bonus_delay_order(battler, value) unless BonusManager.full_guard?
  end
end

module BonusManager
  module_function
  include Rokan::Kiseki_Plugin
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def init_manager
@rate_list = []
@bonus_list = []
clear
  end
  #--------------------------------------------------------------------------
  # ● クリア
  #--------------------------------------------------------------------------
  def clear
@rate_list.clear
@bonus_list.clear
@sprites_listener = nil
  end
  #--------------------------------------------------------------------------
  # ● クリティカル判定
  #--------------------------------------------------------------------------
  def critical?
get_bonus == 6 && $game_party.in_battle
  end
  #--------------------------------------------------------------------------
  # ● 完全防御判定
  #--------------------------------------------------------------------------
  def full_guard?
get_bonus == 7 && $game_party.in_battle
  end
  #--------------------------------------------------------------------------
  # ● ラッシュ判定
  #--------------------------------------------------------------------------
  def rash?
get_bonus == 8
  end
  #--------------------------------------------------------------------------
  # ● アクティブなボーナスの取得
  #--------------------------------------------------------------------------
  def get_bonus
@bonus_list[1]
  end
  #--------------------------------------------------------------------------
  # ● インデックスを指定したボーナスの取得
  #--------------------------------------------------------------------------
  def get_bonus_with_index(index)
@bonus_list[index]
  end
  #--------------------------------------------------------------------------
  # ● 新たに追加するボーナスの取得
  #--------------------------------------------------------------------------
  def get_pop_bonus
case rand(@rate_list[9].last)
when @rate_list[0]; -1
when @rate_list[1];  0
when @rate_list[2];  1
when @rate_list[3];  2
when @rate_list[4];  3
when @rate_list[5];  4
when @rate_list[6];  5
when @rate_list[7];  6
when @rate_list[8];  7
when @rate_list[9];  8
else; -1
end
  end
  #--------------------------------------------------------------------------
  # ● ボーナスの初期化
  #--------------------------------------------------------------------------
  def init_bonus
init_bonus_rate
@bonus_list.clear
10.times{@bonus_list << get_pop_bonus}
  end
  #--------------------------------------------------------------------------
  # ● ボーナス発生確率の初期化
  #--------------------------------------------------------------------------
  def init_bonus_rate
@rate_list.clear
first = last = 0
BOP[$game_variables[BCV]].each_with_index{|value, index|
   last += value unless value.zero?
   @rate_list << Range.new(first, last)
   first = last
}
  end
  #--------------------------------------------------------------------------
  # ● ボーナスを進める
  #--------------------------------------------------------------------------
  def next_bonus
@bonus_list.shift
@bonus_list << get_pop_bonus
@sprites_listener.next_bonus if @sprites_listener
  end
  #--------------------------------------------------------------------------
  # ● ボーナススプライトを可視化する
  #--------------------------------------------------------------------------
  def sprites_listener=(obj)
@sprites_listener = obj
  end
end
BonusManager.init_manager

class Game_ActionResult
  #--------------------------------------------------------------------------
  # ● ダメージ値のクリティカル補正
  #--------------------------------------------------------------------------
  def critical_damage_values
@hp_damage = (@hp_damage * 1.5).to_i
@mp_damage = (@mp_damage * 1.5).to_i
@hp_drain = (@hp_drain * 1.5).to_i
@mp_drain = (@mp_drain * 1.5).to_i
  end
end

class Game_Battler
  #--------------------------------------------------------------------------
  # ● ダメージの処理
  #--------------------------------------------------------------------------
  alias _kiseki_bonus_execute_damage execute_damage
  def execute_damage(user)
if BonusManager.critical?
   @result.critical_damage_values
elsif BonusManager.full_guard?
   @result.clear_damage_values
   @result.cancel = false
end
_kiseki_bonus_execute_damage(user)
  end
  #--------------------------------------------------------------------------
  # ● 使用効果［HP 回復］　※再定義
  #--------------------------------------------------------------------------
  def item_effect_recover_hp(user, item, effect)
value = (mhp * effect.value1 + effect.value2) * rec
value *= user.pha if item.is_a?(RPG::Item)
value *= 1.5 if BonusManager.critical? # 追加
value = value.to_i
@result.hp_damage -= value
@result.success = true
self.hp += value
  end
  #--------------------------------------------------------------------------
  # ● 使用効果［MP 回復］　※再定義
  #--------------------------------------------------------------------------
  def item_effect_recover_mp(user, item, effect)
value = (mmp * effect.value1 + effect.value2) * rec
value *= user.pha if item.is_a?(RPG::Item)
value *= 1.5 if BonusManager.critical? # 追加
value = value.to_i
@result.mp_damage -= value
@result.success = true if value != 0
self.mp += value
  end
  #--------------------------------------------------------------------------
  # ● 使用効果［TP 増加］　※再定義
  #--------------------------------------------------------------------------
  def item_effect_gain_tp(user, item, effect)
value = effect.value1.to_i
value *= 1.5 if BonusManager.critical? # 追加
@result.tp_damage -= value
@result.success = true if value != 0
self.tp += value
  end
  #--------------------------------------------------------------------------
  # ● ステートの付加可能判定
  #--------------------------------------------------------------------------
  alias _kiseki_bonus_state_addable? state_addable?
  def state_addable?(state_id)
_kiseki_bonus_state_addable?(state_id) && !BonusManager.full_guard?
  end
  #--------------------------------------------------------------------------
  # ● 使用効果［ステート解除］
  #--------------------------------------------------------------------------
  alias _kiseki_bonus_item_effect_remove_state item_effect_remove_state
  def item_effect_remove_state(user, item, effect)
_kiseki_bonus_item_effect_remove_state(user, item, effect) unless BonusManager.full_guard?
  end
  #--------------------------------------------------------------------------
  # ● ボーナスによる回復適用
  #--------------------------------------------------------------------------
  def bonus_recover_effect
@result.clear
@result.used = (0..5).include?(BonusManager.get_bonus)
case BonusManager.get_bonus
when 0
   self.hp -= @result.hp_damage = -(mhp * 0.1).to_i
when 1
   self.hp -= @result.hp_damage = -(mhp * 0.5).to_i
when 2
   self.mp -= @result.mp_damage = -(mmp * 0.1).to_i
when 3
   self.mp -= @result.mp_damage = -(mmp * 0.5).to_i
when 4
   self.tp -= @result.tp_damage = -10
when 5
   self.tp -= @result.tp_damage = -50
end
  end
end

class Bonus < Sprite
  include Saba::Kiseki
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(viewport, index)
super(viewport)
@index = index
set_bitmap unless @index.zero?
if self.bitmap
   self.x = MARGIN_LEFT + 40
   self.y = set_new_y
   self.z = 4
   self.ox = self.bitmap.width / 2
   self.oy = self.bitmap.height
end
self.opacity = 0
  end
  #--------------------------------------------------------------------------
  # ● ボーナスIDの取得
  #--------------------------------------------------------------------------
  def get_bonus
BonusManager.get_bonus_with_index(@index)
  end
  #--------------------------------------------------------------------------
  # ● ビットマップのセット
  #--------------------------------------------------------------------------
  def set_bitmap
case get_bonus
when 0
   self.bitmap = Cache.system("AT_BONUS_HP10")
when 1
   self.bitmap = Cache.system("AT_BONUS_HP50")
when 2
   self.bitmap = Cache.system("AT_BONUS_MP10")
when 3
   self.bitmap = Cache.system("AT_BONUS_MP50")
when 4
   self.bitmap = Cache.system("AT_BONUS_TP10")
when 5
   self.bitmap = Cache.system("AT_BONUS_TP50")
when 6
   self.bitmap = Cache.system("AT_BONUS_CRI")
when 7
   self.bitmap = Cache.system("AT_BONUS_DUARD")
when 8
   self.bitmap = Cache.system("AT_BONUS_RASH")
end
  end
  #--------------------------------------------------------------------------
  # ● 移動先の y 座標を設定
  #--------------------------------------------------------------------------
  def set_new_y
@new_y = 32
@new_y += MARGIN_CURRENT_BOTTOM if @index > 1
@new_y += MARGIN_TOP + UNIT_INTERVAL * (@index-1)
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
if self.bitmap
   super
   update_x
   update_y
   update_z
   update_zoom
   update_opacity
end
  end
  #--------------------------------------------------------------------------
  # ● x 座標の更新
  #--------------------------------------------------------------------------
  def update_x
  end
  #--------------------------------------------------------------------------
  # ● y 座標の更新
  #--------------------------------------------------------------------------
  def update_y
if self.y != @new_y
   self.y = [self.y - ((@new_y - self.y).abs < 3 ? 1 : 3), @new_y].max
   flash_top_bonus if @index == 1 && self.y == @new_y
end
  end
  #--------------------------------------------------------------------------
  # ● z 座標の更新
  #--------------------------------------------------------------------------
  def update_z
self.z = @index > 1 ?  4 : 7
  end
  #--------------------------------------------------------------------------
  # ● 拡大率の更新
  #--------------------------------------------------------------------------
  def update_zoom
if (get_bonus == -1 || @index.zero?) && !self.zoom_x.zero?
   self.zoom_x = self.zoom_y -= 0.05
end
  end
  #--------------------------------------------------------------------------
  # ● 透明度の更新
  #--------------------------------------------------------------------------
  def update_opacity
self.opacity += 12 if self.opacity != 255
  end
  #--------------------------------------------------------------------------
  # ● ボーナスを進める
  #--------------------------------------------------------------------------
  def next_bonus
@index -= 1
set_new_y unless @index.zero?
  end
  #--------------------------------------------------------------------------
  # ● 先頭に到達したボーナスをフラッシュさせてみる
  #--------------------------------------------------------------------------
  def flash_top_bonus
flash(Color.new(255, 255, 255, 196), 40)
  end
end

class Bonus_Spriteset
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(viewport)
@viewport = viewport
create_bonus
  end
  #--------------------------------------------------------------------------
  # ● ボーナススプライトの生成
  #--------------------------------------------------------------------------
  def create_bonus
@bonus_sprites = []
10.times{|i| @bonus_sprites << Bonus.new(@viewport, i)}
  end
  #--------------------------------------------------------------------------
  # ● ボーナスを１つ進める
  #--------------------------------------------------------------------------
  def next_bonus
@bonus_sprites.shift.dispose
@bonus_sprites.each{|bonus| bonus.next_bonus}
@bonus_sprites << Bonus.new(@viewport, 8)
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  def dispose
@bonus_sprites.each{|bonus| bonus.dispose}
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
@bonus_sprites.each{|bonus| bonus.update}
  end
end

class Spriteset_Battle
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  alias _kiseki_bonus_initialize initialize
  def initialize
_kiseki_bonus_initialize
@bonus_spriteset = Bonus_Spriteset.new(@viewport3)
BonusManager.sprites_listener = @bonus_spriteset
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  alias _kiseki_bonus_update update
  def update
_kiseki_bonus_update
@bonus_spriteset.update if @bonus_spriteset
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  alias _kiseki_bonus_dispose dispose
  def dispose
_kiseki_bonus_dispose
@bonus_spriteset.dispose
  end
end

class Window_BattleLog < Window_Selectable
  include Rokan::Kiseki_Plugin
  #--------------------------------------------------------------------------
  # ● クリティカルヒットの表示
  #--------------------------------------------------------------------------
  alias _kiseki_bonus_display_critical display_critical
  def display_critical(target, item)
display_critical_bonus
_kiseki_bonus_display_critical(target, item)
  end
  #--------------------------------------------------------------------------
  # ● クリティカルボーナスの表示
  #--------------------------------------------------------------------------
  def display_critical_bonus
if BonusManager.critical?
   add_text(CriticalBonusText)
   wait
end
  end
  #--------------------------------------------------------------------------
  # ● ボーナスによる回復結果の表示
  #--------------------------------------------------------------------------
  def display_bonus_recover(target)
if target.result.used
   Sound.play_recovery
   last_line_number = line_number
   case BonusManager.get_bonus
   when 0..1
      add_text(target.result.hp_damage_text)
   when 2..3
      add_text(target.result.mp_damage_text)
   when 4..5
      add_text(target.result.tp_damage_text)
   end
   SceneManager.scene.refresh_status
   wait
   wait if line_number > last_line_number
   back_to(last_line_number)
end
  end
end

class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  # ● パーティコマンド選択の開始
  #--------------------------------------------------------------------------
  alias _kiseki_bonus_start_party_command_selection start_party_command_selection
  def start_party_command_selection
battler = OrderManager.top_unit.battler
battler.bonus_recover_effect
@log_window.display_bonus_recover(battler)
_kiseki_bonus_start_party_command_selection
  end
end

逃跑
class Scene_Battle
  #--------------------------------------------------------------------------
  # ● アクターコマンドウィンドウの作成
  #--------------------------------------------------------------------------
  alias saba_kiseki_escape_create_actor_command_window create_actor_command_window
  def create_actor_command_window
saba_kiseki_escape_create_actor_command_window
@actor_command_window.set_handler(:escape, method(:command_escape))
  end
end

class Window_ActorCommand
  #--------------------------------------------------------------------------
  # ● コマンドリストの作成
  #--------------------------------------------------------------------------
  alias saba_kiseki_escape_make_command_list make_command_list
  def make_command_list
saba_kiseki_escape_make_command_list
add_command(Vocab::escape, :escape, BattleManager.can_escape?)
  end
end

  上述是碧轨系统所有脚本.如果还不行的话我建议你还是别用了.这套脚本我之前也用过.跟原脚本冲突.BUG很多

vince3725 · 发表于 2012-10-27 16:16:03

undefined method '>=' for nil:NilClass  你缺少地图信息这个脚本：
  #==============================================================================
# ■ 碧の軌跡っぽいステータス表示
# @version 0.13 12/01/07
# @author さば缶
#------------------------------------------------------------------------------
# 　マップ画面下にステータスが表示されます
#
#  ■用意するもの
# Graphics\System の下に Actor_bg1 ～ Actor_bg3
# Graphics\Faces の下に顔グラを50%に縮小したファイル "通常のファイル名_s"
# 例 Actor1.png → Actor1_s.png
# ※このファイルが存在しない場合、プログラムで縮小するため非常に荒くなります
#
#==============================================================================
module Saba
  module KisekiStatus
# このスイッチがONの場合、ステータスを表示します
INVISIBLE_SWITCH = 211

# TPを表示する場合、true に設定します。
SHOW_TP = true
  end
end

class Window_KisekiStatus < Window_Selectable
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize
super(0, Graphics.height-window_height+18, Graphics.width, window_height)
self.opacity = 0
self.visible = $game_switches[Saba::KisekiStatus::INVISIBLE_SWITCH]

refresh
  end
  def refresh
@last_hps = []
@last_mps = []
@last_tps = []
super
  end
  #--------------------------------------------------------------------------
  # ● 項目数の取得
  #--------------------------------------------------------------------------
  def item_max
$game_party.battle_members.size
  end
  #--------------------------------------------------------------------------
  # ● ウィンドウの高さを取得
  #--------------------------------------------------------------------------
  def window_height
item_height+32
  end
  #--------------------------------------------------------------------------
  # ● 項目の高さを取得
  #--------------------------------------------------------------------------
  def item_height
52
  end
  #--------------------------------------------------------------------------
  # ● 項目の幅を取得
  #--------------------------------------------------------------------------
  def item_width
return 70
  end
  #--------------------------------------------------------------------------
  # ● 桁数の取得
  #--------------------------------------------------------------------------
  def col_max
return $game_party.battle_members.size
  end
  #--------------------------------------------------------------------------
  # ● 項目の描画
  #--------------------------------------------------------------------------
  def draw_item(index)
actor = $game_party.battle_members[index]
rect = item_rect(index)

bg_bitmap = Cache.system("Actor_bg1")
contents.blt(rect.x, rect.y, bg_bitmap, bg_bitmap.rect)

small_bitmap = Bitmap.new(48, 48)
begin
   bitmap = Cache.face(actor.face_name + "_s")
rescue
end
if bitmap == nil
   bitmap = Cache.face(actor.face_name)
   face_rect = Rect.new(actor.face_index % 4 * 96, actor.face_index / 4 * 96, 96, 96)
   small_bitmap.stretch_blt(Rect.new(0, 0, 48, 48), bitmap, face_rect)
else
   small_bitmap.blt(0, 0, bitmap, Rect.new(actor.face_index % 4 * 48,  actor.face_index / 4 * 48, 48, 48))
end
bitmap.dispose
clear_edge(small_bitmap)

contents.blt(rect.x+2, 2, small_bitmap, Rect.new(0, 0, 48, 48))
small_bitmap.dispose

if actor.dead?
   bg_bitmap = Cache.system("Actor_bg1")
   contents.blt(rect.x, rect.y, bg_bitmap, bg_bitmap.rect)
   bg_bitmap = Cache.system("Actor_bg3")
else
   bg_bitmap = Cache.system("Actor_bg2")
end
contents.blt(rect.x, rect.y, bg_bitmap, bg_bitmap.rect)

draw_gauge(rect.x + 47, rect.y+20, 50, actor.hp_rate, hp_gauge_color1, hp_gauge_color2)
draw_gauge(rect.x + 42, rect.y+24, 50, actor.mp_rate, mp_gauge_color1, mp_gauge_color2)
if Saba::KisekiStatus::SHOW_TP
   draw_gauge(rect.x + 37, rect.y+28, 50, actor.tp_rate, tp_gauge_color1, tp_gauge_color2)
end
@last_hps.push(actor.hp_rate)
@last_mps.push(actor.mp_rate)
@last_tps.push(actor.tp_rate)
  end
  #--------------------------------------------------------------------------
  # ● 顔画像の端を消します
  #--------------------------------------------------------------------------
  def clear_edge(bitmap)
22.times  { |i|
   bitmap.clear_rect(0, i, 22 - i, 1)
   bitmap.clear_rect(26 + i, i, 22 - i, 1)
   bitmap.clear_rect(0, i + 26, i, 1)
   bitmap.clear_rect(48 - i, i + 26, i, 1)
}
  end
  #--------------------------------------------------------------------------
  # ● ゲージの描画
  #    rate : 割合（1.0 で満タン）
  #    color1 : グラデーション左端
  #    color2 : グラデーション右端
  #--------------------------------------------------------------------------
  def draw_gauge(x, y, width, rate, color1, color2)
fill_w = (width * rate).to_i
gauge_y = y + line_height - 8

contents.fill_rect(x-2, gauge_y-1, width+4, 4, text_color(15))
contents.fill_rect(x-1, gauge_y-2, width+2, 6, text_color(15))
contents.fill_rect(x, gauge_y, width, 2, gauge_back_color)
contents.gradient_fill_rect(x, gauge_y, fill_w, 2, color1, color2)
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
super
if $game_switches[Saba::KisekiStatus::INVISIBLE_SWITCH] == true &&
   ! $game_message.busy? && ! $game_message.visible
   self.visible = true
else
   self.visible = false
   return
end
hps = []
mps = []
tps = []
for actor in $game_party.battle_members
   hps.push(actor.hp_rate)
   mps.push(actor.mp_rate)
   tps.push(actor.tp_rate)
end

if @last_hps != hps || @last_mps != mps || @last_tps != tps
   refresh
end
  end
end

class Scene_Map
  #--------------------------------------------------------------------------
  # ● 全ウィンドウの作成
  #--------------------------------------------------------------------------
  alias saba_kiseki_status_create_all_windows create_all_windows
  def create_all_windows
saba_kiseki_status_create_all_windows
@kiseki_status_window = Window_KisekiStatus.new
  end
end
  插在战斗脚本上面

vince3725 · 发表于 2012-10-27 00:07:40

def battle_party_change?

switch = YEA::COMMAND_PARTY::ENABLE_SWITCH

enabled = switch <= 0 ? true : $game_switches[switch]

return false unless enabled

reset_party_cooldown if @party_cooldown.nil?

return @party_cooldown <= 0

end
把红色的地方改成 >=0 就能自由换人了

vince3725 · 发表于 2012-10-26 23:09:15

我给你个坐标脚本..你这个是定议脚本【没有坐标】把脚本插到它上面就行了：
#==============================================================================
# ■ SideViewアクション設定
#------------------------------------------------------------------------------
# 　サイドビューバトル全般のセッティングやアクションを作成します
#==============================================================================
module N03
#--------------------------------------------------------------------------
# ● 全体のセッティング
#--------------------------------------------------------------------------
  # アクター初期位置　一人目    二人目    三人目    四人目
  #                   X軸 Y軸 H軸  X軸 Y軸 H軸  X軸 Y軸 H軸  X軸 Y軸 H軸
  ACTOR_POSITION = [[460,160, 0],[480,185, 0],[500,210, 0],[520,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ダメージ数字画像のファイル名(Systemフォルダを参照します)
  DAMAGE_MP = "damage_mp"
  # TPダメージ数字画像のファイル名(Systemフォルダを参照します)
  DAMAGE_TP = "damage_tp"
  # ダメージ数字の文字間隔を調整
  DAMAGE_ADJUST = -4

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

#--------------------------------------------------------------------------
# ● 戦闘背景セッティング  背景の座標調整や拡大率を設定します
#--------------------------------------------------------------------------
  # 床背景ﾌｧｲﾙ名…設定する床背景(Battlebacks1)画像ﾌｧｲﾙ名。
  #             "全Battlebacks1"は指定のないBattlebacks1画像を一括設定する項目です
  # 壁背景ﾌｧｲﾙ名…設定する壁背景(Battlebacks2)画像ﾌｧｲﾙ名。
  #             "全Battlebacks2"は指定のないBattlebacks2画像を一括設定する項目です
  # 座標調整…[X軸, Y軸]
  # 拡大率……[横拡大率, 縦拡大率]
  # ｼｪｲｸ可……シェイクアクションで揺れを許可するならtrue　しないならfalse
  # ｽｲｯﾁﾄﾘｶﾞｰ…戦闘開始時に自動でONにするｹﾞｰﾑｽｲｯﾁ番号。ﾏｲﾅｽでｻｲﾄﾞﾋﾞｭｰ専用ｽｲｯﾁがON
  #          背景とﾊﾞﾄﾙﾌﾟﾛｸﾞﾗﾑをセットで管理したい場合などに利用します
  #          スイッチ操作をしないなら0

FLOOR1_DATA = {
#――床背景ﾌｧｲﾙ名―――       座標調整    拡大率ｼｪｲｸ可  ｽｲｯﾁﾄﾘｶﾞｰ
  "Sea_ex01"             => [ [ 0, 120], [ 150, 150], false, -1],
  "全Battlebacks1"       => [ [ 0, 120], [ 150, 150],  true, 0],

  }
FLOOR2_DATA = {
  #――壁背景ﾌｧｲﾙ名―――       座標調整    拡大率ｼｪｲｸ可  ｽｲｯﾁﾄﾘｶﾞｰ
  "Ship_ex"             => [ [ 0, 120], [ 150, 150],  true, 0],
  "全Battlebacks2"       => [ [ 0, 120], [ 150, 150],  true, 0],


}

#==============================================================================
# ■ アクション
#------------------------------------------------------------------------------
# 　バトラーが戦闘中に行う単発行動です。組み合わせてフルアクションにできます
#==============================================================================
# ここのアクション名やフルアクション名は、かぶらないようにしてください
  ACTION = {

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

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

  #―ｱｸｼｮﾝ名(待機系)― 判別ｲﾝﾃﾞｯｸｽ  縦ｾﾙ横ｾﾙﾊﾟﾀｰﾝ速度  Z軸  ｳｴｲﾄ影武器
  "待機"          => ["motion", "", 1, 0, 4, 12, 0, true, true, "" ],
  "待機固定WT"    => ["motion", "", 1, 1, 0, 12, 0, true, true, "" ],
  "待機固定"       => ["motion", "", 1, 1, 0, 12, 0,false, true, "" ],
  "倒れ"          => ["motion", "_1", 0, 0, 0, 12, 0, true,false, "" ],
  "右向き"       => ["motion", "", 2, 0, 4, 12, 0, true, true, "" ],

  #―ｱｸｼｮﾝ名(移動系)― 判別ﾌｧｲﾙNo 縦ｾﾙ横ｾﾙﾊﾟﾀｰﾝ速度  Z軸ｳｴｲﾄ影武器
  "左向き移動"    => ["motion", "", 1, 0, 4, 6,  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…独自画像(画像名はﾊﾞﾄﾗｰ設定の武器の項目で行います。参照先はCharactersフォルダ)]
  #    [2…アニメセル(※2003仕様。ﾊﾞﾄﾗｰと同じｾﾙ数でｱﾆﾒします。画像名はﾊﾞﾄﾗｰ設定の武器の項目で行います。参照先はCharactersフォルダ)]
  # 移動…画像を動かす距離。[X軸, Y軸]
  # 調整…微調整する画像の初期座標。[X軸, Y軸]
  # 始度…動作前の最初の角度。反時計回りで0～360度。負が時計回り
  # 終度…動作後の角度
  # 原点…画像の原点。[0…中心] [1…左上] [2…右上] [3…左下] [4…右下] [5…バトラーと同じ(画像下と縦半分)]
  # 反転…trueにすると画像を反転して表示
  # 拡大…[X軸拡大率, Y軸拡大率] 小数点でも受け付けます
  # Z軸…画像をキャラより手前に表示するならtrue
  # 逆手…盾画像、もしくは二刀流時の左(項目だと下)の武器画像を表示
  #    アイコンを利用しない場合、盾の画像はﾊﾞﾄﾗｰ設定の盾の項目で行います
  # 更新…-1でバトラーアニメ更新と同期化。独立させる場合は [更新時間間隔, 更新パターン数, ループするか]
  #
  # ｲﾝﾃﾞｯｸｽ…武器画像は装備している武器(盾)に設定された画像ﾌｧｲﾙを参照しますが、
  #       ここでｲﾝﾃﾞｯｸｽを付けると、画像ﾌｧｲﾙ名+ｲﾝﾃﾞｯｸｽ名の画像を参照します
  #       一つの武器で複数のﾊﾟﾀｰﾝがある画像を用いる場合に利用します
  #       例) "縦振り"のｲﾝﾃﾞｯｸｽは"" => 画像ﾌｧｲﾙ名"IconSet"を参照
  #       例) "縦振り2"のｲﾝﾃﾞｯｸｽは"_1" => 画像ﾌｧｲﾙ名"IconSet_1"を参照
  #       参照ﾌｫﾙﾀﾞはｱｲｺﾝ利用の場合はSystemﾌｫﾙﾀﾞ、独自画像とｱﾆﾒｾﾙはCharactersフォルダです
  #
  # 画像…武器や盾に設定された画像ﾌｧｲﾙやｲﾝﾃﾞｯｸｽを無視して、武器画像を直接指定する場合は
  #    ここに画像ﾌｧｲﾙ名を入れます。画像はCharactersフォルダを参照します

  #―ｱｸｼｮﾝ名― 判別ﾀｲﾌﾟ  移動    調整始度終度原点反転拡大 Z軸逆手更新  ｲﾝﾃﾞｯｸｽ  画像
  "縦振り" => ["wp", 0,[  6, 0],[ -4,-10], -45,  45,  4, false, [1,1], false, false, -1, "", ""],
  "盾"       => ["wp", 0,[  0, 0],[ 12,  0], 0, 0,  4, false, [1,1],  true,  true, -1, "", ""],
  "縦振りL" => ["wp", 0,[  6, 0],[  0, -8],-135,  45,  4, false, [1,1],  true,  true, -1, "", ""],
  "拳突き" => ["wp", 0,[-20, 0],[  5,  5], -45, -45,  4, false, [1,1], false, false, -1, "", ""],
  "突き"    => ["wp", 0,[-25, 0],[ 25,-10],  45,  45,  4, false, [1,1], false, false, -1, "", ""],
  "掲げ"    => ["wp", 0,[  6,-4],[ -4,-10],  90, -45,  4, false, [1,1], false, false, -1, "", ""],

  #―2003仕様― 判別ﾀｲﾌﾟ  移動    調整始度終度原点反転拡大 Z軸逆手更新  ｲﾝﾃﾞｯｸｽ  画像
  "弓"       => ["wp", 2,[  0, 0],[  0,  0], 0, 0,  5, false, [1,1],  true, false, -1, "", ""],

  # 武器飛ばし用  判別ﾀｲﾌﾟ  移動    調整始度終度原点反転拡大 Z軸二刀    更新    ｲﾝﾃﾞｯｸｽ  画像
  "矢"       => ["wp", 0,[  0, 0],[  0,  0], 0,  45,  0, false, [1,1],  true, false,[2,6,false], "", "arrow01"],
  "回転"    => ["wp", 0,[  0, 0],[  0,  0], 0, 360,  0, false, [1,1],  true, false,[1,8, true], "", ""],

#--------------------------------------------------------------------------
# ● 武器・アニメ飛ばし　武器や戦闘アニメを移動させます。飛び道具などに
#--------------------------------------------------------------------------
  # ID…ﾃﾞｰﾀﾍﾞｰｽのｱﾆﾒID。[移動させるｱﾆﾒ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が完全に不透明な状態
  # 終了…変更終了時の透明度
  # 影…影も同じ透明度操作をするならtrue
  # 武器…武器も同じ透明度操作をするならtrue
  # ﾙｰﾌﾟ…透明度変更が終了した後、操作を自動で逆転させ続けるならtrue
  # ｳｴｲﾄ…操作終了まで次のアクションに移行せず待つならtrue

  #――ｱｸｼｮﾝ名――  　    判別時間  開始  終了影武器ﾙｰﾌﾟ  ｳｴｲﾄ
  "逃走透明"       => ["opacity", 30,  255, 0,  true,  true, false, false],
  "透明化"          => ["opacity", 60,  255, 0,  true,  true, false, false],
  "透明化WT"       => ["opacity", 60,  255, 0,  true,  true, false,  true],
  "透明化解除"    => ["opacity", 60, 0, 255,  true,  true, false, false],
  "透明化解除WT"    => ["opacity", 60, 0, 255,  true,  true, false,  true],

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

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

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

  #―――ｱｸｼｮﾝ名――― 判別  番号  開始座標    終了座標時間 Z軸透明度ﾌﾟﾚｰﾝ使用  BA反転ﾋﾟｸﾁｬﾌｧｲﾙ名
  "カットインA1" => ["pic",  0, [-300, 8], [ 100, 8],  30, 90, [  0, 10],       [],  true, "Actor4-1"],
  "カットインA2" => ["pic",  0, [-300, 8], [ 100, 8],  30, 90, [  0, 10],       [],  true, "Actor4-2"],
  "カットインA3" => ["pic",  0, [-300, 8], [ 100, 8],  30, 90, [  0, 10],       [],  true, "Actor5-2"],
  "カットインA4" => ["pic",  0, [-300, 8], [ 100, 8],  30, 90, [  0, 10],       [],  true, "Actor5-3"],
  "カットイン終" => ["pic",  0,       [], [ 600, 8],  30, 90, [255,  0],       [],  true, ""],
  "カットイン背景始"=> ["pic",  1, [ 0, 8], [ 100, 8],  10, 80, [  0, 10], [544,288],  true, "cutin_back"],
  "カットイン背景終"=> ["pic",  1,       [],       [],  10, 80, [255, -7], [544,288],  true, ""],
  "白フェードイン"  => ["pic",  0, [ 0, 0], [ 0, 0],  50,500, [  0,  6],       [], false, "white"],
  "白フェードアウト"=> ["pic",  0, [ 0, 0], [ 0, 0],  50,500, [255, -6],       [], false, "white"],

#--------------------------------------------------------------------------
# ● ステート操作
#--------------------------------------------------------------------------
  # 対象…[0=自分] [1=ﾀｰｹﾞｯﾄ] [2=敵全] [3=味方全] [4=敵味方全] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ]
  # 拡張…上で設定した対象をさらに拡張します [0=拡張なし] [1=ﾗﾝﾀﾞﾑ1体] [2=自分を除く]
  # 操作…ステートを付与するなら"+"　解除するなら"-"
  # ｽﾃｰﾄID…操作するステートのIDをまとめて配列に入れます

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

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

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

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

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

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

  #―――ｱｸｼｮﾝ名――― 判別習得  ｺｽﾄ条件  ｽｷﾙID
  "多段攻撃に派生" => ["der",  true,  false, 1],

#--------------------------------------------------------------------------
# ● サウンドの演奏  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・MP・TP限定)
  # 条件…参照したﾊﾟﾗﾒｰﾀが条件の数字と比べて…[0=同じ] [1=少ない] [2=多い]
  # 人数…上の条件となる必要人数。条件対象がグループの場合、0でグループ全員の数になります
  # 分岐…条件を満たした場合の分岐処理。満たさない場合はその逆の処理がされます
  #    [0=次のｱｸｼｮﾝを実行] [1=次のｱｸｼｮﾝをｷｬﾝｾﾙ] [2=ﾌﾙｱｸｼｮﾝ終了]
  #
  #―――ｱｸｼｮﾝ名―――    判別  対象  種別  数値  条件  人数  分岐
  "HP50%以上で実行"    => ["n_5",  0, 4,  -50, 2, 1, 0],

#--------------------------------------------------------------------------
# ● 条件分岐 (装備)
#--------------------------------------------------------------------------
  # 対象…条件を参照する対象 [0=自分] [1=ﾀｰｹﾞｯﾄ] [2=敵全体] [3=味方全体] [4=敵味方全体] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ]
  # 種類…条件となる装備の種類 [0=武器] [1=防具]
  # 装備ID…上の種類のアイテムID。IDは一括して配列[]に入れます。
  #       マイナスで武器(防具)タイプを参照します
  # 条件…[0=装備している] [1=装備していない]
  # 人数…上の条件となる必要人数。条件対象がグループの場合、0でグループ全員の数になります
  # 分岐…条件を満たした場合の分岐処理。満たさない場合はその逆の処理がされます
  #    [0=次のｱｸｼｮﾝを実行] [1=次のｱｸｼｮﾝをｷｬﾝｾﾙ] [2=ﾌﾙｱｸｼｮﾝ終了]
  #
  #―――ｱｸｼｮﾝ名―――    判別  対象  種類    ID 条件  人数  分岐
  "ハンドアクス限定"    => ["n_6",  0, 0, [1], 0, 1, 0],
  "拳限定"             => ["n_6",  0, 0, [-2], 0, 1, 0],
  "拳除外"             => ["n_6",  0, 0, [-2], 0, 1, 1],
  "弓限定"             => ["n_6",  0, 0, [-6], 0, 1, 0],
  "弓除外"             => ["n_6",  0, 0, [-6], 0, 1, 1],
  "拳弓除外"          => ["n_6",  0, 0,[-2,-6], 0, 1, 1],

#--------------------------------------------------------------------------
# ● 条件分岐 (スクリプト)　
#--------------------------------------------------------------------------
  # 分岐…条件を満たした場合の分岐処理。満たさない場合はその逆の処理がされます
  #    [0=次のｱｸｼｮﾝを実行] [1=次のｱｸｼｮﾝをｷｬﾝｾﾙ] [2=ﾌﾙｱｸｼｮﾝ終了]
  # ｽｸﾘﾌﾟﾄ…trueかfalseを返すスクリプトを入れます
  #
  #―――ｱｸｼｮﾝ名―――    判別分岐  ｽｸﾘﾌﾟﾄ
  "50%の確率で実行"    => ["n_7", 0,  "rand(100) < 50"],
  "アクター限定"       => ["n_7", 0,  "@battler.actor?"],
  "アクターID1限定"    => ["n_7", 0,  "@battler.actor? && @battler.actor_id == 1"],
  "アクターID2限定"    => ["n_7", 0,  "@battler.actor? && @battler.actor_id == 2"],
  "アクターID6限定"    => ["n_7", 0,  "@battler.actor? && @battler.actor_id == 6"],
  "アクターID7限定"    => ["n_7", 0,  "@battler.actor? && @battler.actor_id == 7"],
  "エネミー限定"       => ["n_7", 0,  "[email protected]?"],
  "エネミー中止"       => ["n_7", 2,  "[email protected]?"],
  "二刀流限定"          => ["n_7", 0,  "@battler.dual_wield?"],

#--------------------------------------------------------------------------
# ● セカンドターゲット操作
#--------------------------------------------------------------------------
  # セカンドターゲットとは、通常のターゲットとは別の独立したターゲット情報です
  # 何も操作しない場合、通常ターゲットと同じ対象がセットされています
  #
  # 対象…[0=自分] [1=ターゲット] [2=敵全体] [3=味方全体] [4=敵味方全体] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ]
  #
  # INDEX…対象をﾊﾟｰﾃｨのｲﾝﾃﾞｯｸｽ(並び順)で絞込みます INDEX = [ｲﾝﾃﾞｯｸｽ, 判別]
  #       ｲﾝﾃﾞｯｸｽ…ﾊﾟｰﾃｨのｲﾝﾃﾞｯｸｽ数値
  #       判別…数値の条件 [0=絞込まない] [1=そのｲﾝﾃﾞｯｸｽが対象に] [2=そのｲﾝﾃﾞｯｸｽを排除]
  #
  # ID…対象をｱｸﾀｰ(ｴﾈﾐｰ)IDで絞込むなら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 "],

#--------------------------------------------------------------------------
# ● その他　設定項目なしでフルアクションに入れます
#--------------------------------------------------------------------------
  # 戦闘アニメ消去…表示中の戦闘アニメを消去します(飛ばしアニメは消去されません)
  # 強制戦闘終了…戦闘を強制終了させます
  # 画面固定…ｹﾞｰﾑ画面を固定させます。ﾄﾗﾝｼﾞｼｮﾝ前に入れます
  # ダメージアニメ…スキルアニメを再生し、それが終わる直前にダメージをPOPさせます
  # 反転…画像と武器アニメを反転します。再度反転させるかフルアクション終了で反転解除
  # 武器消去…表示中の武器画像を消去します
  # 武器消去解除…消去した武器画像を表示します
  # 敵コラプス…崩御エフェクトを実行します。主に敵の戦闘不能に使用します
  # コラプス禁止…対象の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"],
  "身代わり開始" => ["敵中移動早","初期位置変更"],
  "身代わり終了" => ["初期位置変更解除","座標リセット左向き"],
  "被身代わり開始"  => ["一歩後移動","一歩後移動","待機固定WT"],
  "被身代わり終了"  => ["座標リセット左向き"],
  "勝利ポーズ振り"  => ["戦闘アニメ消去","勝利ジャンプ武器","勝利ジャンプ着地","120"],
  "勝利ポーズバク転"=> ["戦闘アニメ消去","右1回転","勝利ジャンプ","拳限定","武器拳突き","拳除外","武器振りR","120"],
  "閃き"          => ["anime_me(119)","20"],

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

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

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


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

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

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



  }



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

红色的就是坐标..自己去看

brackwind · 发表于 2012-10-26 20:03:40

呃......這件事很難啟齒
老實說我也看不懂腳本，不清楚定義角色位置的語法是哪一段
真的很抱歉，可以麻煩大大標出來嗎？

橫板：
#==============================================================================
# ■ Sideview
#------------------------------------------------------------------------------
# 　サイドビューバトラーを管理するクラスです。
#==============================================================================
class SideView
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数　
  #--------------------------------------------------------------------------
  attr_accessor :x                   # 画面X座標
  attr_accessor :y                   # 画面Y座標
  attr_accessor :z                   # 画面Z座標
  attr_accessor :h                   # 高さ座標
  attr_accessor :j                   # ジャンプ座標
  attr_accessor :c                   # カーブ座標
  attr_accessor :ox                # 横原点
  attr_accessor :oy                # 縦原点
  attr_accessor :oy_adjust          # 縦原点補正
  attr_accessor :angle             # 回転角度
  attr_accessor :zoom_x             # 横の拡大率
  attr_accessor :zoom_y             # 縦の拡大率
  attr_accessor :pattern_w          # セル横位置（矩形内）
  attr_accessor :pattern_h          # セル縦位置（矩形内）
  attr_accessor :sx                # セル横位置（画像全体）
  attr_accessor :sy                # セル縦位置（画像全体）
  attr_accessor :pattern_type       # セル更新タイプ
  attr_accessor :pattern_time       # セル更新間隔
  attr_accessor :graphic_name       # バトラー画像ファイル名
  attr_accessor :graphic_file_index # バトラー画像ファイル名インデックス
  attr_accessor :graphic_index       # バトラー画像インデックス
  attr_accessor :cw                # セル横矩形
  attr_accessor :ch                # セル縦矩形
  attr_accessor :shadow_visible    # 影表示
  attr_accessor :weapon_visible    # 武器表示

  attr_accessor :wait                # 次の動作待ち時間
  attr_accessor :weapon_index       # 表示中の武器画像インデックス配列
  attr_accessor :weapon_end          # 武器アニメ終了フラグ
  attr_accessor :force_action       # 強制アクション
  attr_accessor :target_battler    # ターゲットバトラー情報
  attr_accessor :second_targets    # セカンドターゲット情報
  attr_accessor :m_a_targets       # アニメ飛ばしターゲット情報
  attr_accessor :individual_targets # 個別処理ターゲットバトラー情報
  attr_accessor :effect_data       # エフェクトデータ
  attr_accessor :anime_id          # アニメID配列
  attr_accessor :anime_move_id       # 飛ばしアニメID配列
  attr_accessor :mirror             # 反転フラグ
  attr_accessor :opacity             # 透明度
  attr_accessor :opacity_data       # 透明度操作情報
  attr_accessor :set_damage          # バトルシーンでのダメージ処理
  attr_accessor :m_a_data          # アニメ飛ばし情報
  attr_accessor :m_a_starter       # アニメ飛ばし開始ターゲット情報
  attr_accessor :action_end          # バトルシーンでの行動終了
  attr_accessor :damage_anime_data # ダメージ戦闘アニメのデータ
  attr_accessor :anime_no_mirror    # 戦闘アニメの反転禁止フラグ
  attr_accessor :anime_horming       # 戦闘アニメのホーミングフラグ
  attr_accessor :anime_camera_zoom # 戦闘アニメがカメラに合わせて拡大縮小するか
  attr_accessor :anime_plus_z       # 戦闘アニメZ座標補正
  attr_accessor :derivation_skill_id  # スキル派生ID
  attr_accessor :immortal          # 不死身フラグ
  attr_accessor :mirage             # 残像データ
  attr_accessor :balloon_data       # ふきだしデータ
  attr_accessor :timing             # 別バトラーからのタイミングデータ
  attr_accessor :timing_targets    # タイミングデータを渡す別バトラー
  attr_accessor :color_set          # 色調変更データ
  attr_accessor :color             # 色調データ
  attr_accessor :change_up          # 画像変更フラグ
  attr_accessor :hit                # 被攻撃回数
  attr_accessor :add_state          # 何度も付加ステートの表示を防ぐフラグ
  attr_accessor :counter_id          # カウンター時のスキルID
  attr_accessor :reflection_id       # 魔法反射時のアニメID
  attr_accessor :result_damage       # ターン終了時のHP変動データ
  attr_accessor :active             # 行動権
  attr_accessor :anime_off          # 戦闘アニメ消去
  attr_accessor :command_action    # コマンドアクションフラグ

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

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

@wait = 0
@weapon_index = []
@weapon_end = true
@full_action = []
@action = []
@force_action = ""
@target_battler = []
@second_targets = []
@individual_targets = []
@m_a_targets = []
@effect_data = []
@anime_id = []
@anime_move_id = []
@opacity = 255
@opacity_data = []
@set_damage = false
@m_a_data = []
@m_a_starter = []
@action_end = false
@damage_anime_data = []
@anime_no_mirror = false
@anime_horming = false
@anime_camera_zoom = false
@anime_plus_z = true
@derivation_skill_id = 0
@immortal = false
@mirage = []
@play_data = []
@balloon_data = []
@picture = false
@timing = []
@timing_targets = []
@color_set = []
@color = []
@change_up = false
@non_motion = false
@graphics_change = false
@hit = 0
@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[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 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
@event_fix = false
@set_damage = false
@action_end = false
@balloon_data = []
@loop_act = []
angle_reset
zoom_reset
opacity_reset
@curve = []
@c = 0
convert_jump
  end
  #--------------------------------------------------------------------------
  # ● 行動終了処理
  #--------------------------------------------------------------------------
  def action_terminate
@mirage = [] if @mirage_end
mirroring_reset
@picture = false
@individual_targets = []
action_setup
# 待機アクションへ移行
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 [email protected]? && N03::ENEMY_MIRROR
mirroring if $sv_camera.mirror
  end
  #--------------------------------------------------------------------------
  # ● 残像実行
  #--------------------------------------------------------------------------
  def mirage_set
@mirage = @action_data.dup
@mirage_end = @mirage[3]
@mirage = [] if @mirage[1] == 0
  end
  #--------------------------------------------------------------------------
  # ● 回転実行
  #--------------------------------------------------------------------------
  def angling(data = @action_data)
@angle_data = data.dup
@oy = @ch / 2
@oy_adjust = @ch * 50
@angle_time = data[1]
start_angle = data[2] * N03.mirror_num(@mirror)
end_angle = data[3] * N03.mirror_num(@mirror)
# 時間が0以下なら即座に最終角度へ
@angle_time = 1 if @angle_time <= 0
# 回転時間から1フレームあたりの角度を出す
@angling = (end_angle - start_angle) / @angle_time
# 割り切れない余りを初期角度に
@angle = (end_angle - start_angle) % @angle_time + start_angle
  end
  #--------------------------------------------------------------------------
  # ● 回転初期化
  #--------------------------------------------------------------------------
  def angle_reset
@oy = @ch
@angle = @angle_time = @oy_adjust = 0
  end
  #--------------------------------------------------------------------------
  # ● 拡大縮小実行
  #--------------------------------------------------------------------------
  def zooming(data = @action_data)
@zoom_data = data.dup
@zoom_time = data[1]
start_zoom_x = data[2][0]
start_zoom_y = data[2][1]
end_zoom_x = data[3][0]
end_zoom_y = data[3][1]
# 時間が0以下なら即座に最終サイズへ
@zoom_time = 1 if @zoom_time <= 0
# 拡大縮小時間から1フレームあたりの拡大縮小率を出す
@zooming_x = (end_zoom_x - start_zoom_x) / @zoom_time
@zooming_y = (end_zoom_y - start_zoom_y) / @zoom_time
# 開始サイズに
@zoom_x = start_zoom_x
@zoom_y = start_zoom_y
  end
  #--------------------------------------------------------------------------
  # ● 拡大縮小初期化
  #--------------------------------------------------------------------------
  def zoom_reset
@zoom_x = @zoom_y = 1
@zoom_time = 0
  end
  #--------------------------------------------------------------------------
  # ● バトラー透明度操作
  #--------------------------------------------------------------------------
  def set_opacity
data = @action_data.dup
@opacity = data[2]
opacity_move = (data[3] - data[2])/ data[1]
@opacity_data = [data[1], data[1], opacity_move, data[4], data[5], data[6]]
@wait = data[1] if data[7]
@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) if anime_data != ""
end
  end
  #--------------------------------------------------------------------------
  # ● アニメ飛ばし開始
  #--------------------------------------------------------------------------
  def move_anime
@m_a_starter = []
@m_a_targets = []
starters = N03.get_targets(@action_data[2], @battler)
targets = N03.get_targets(@action_data[3], @battler)
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 [email protected]?
@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] && [email protected]_learn?($data_skills[@action_data[3]])
# コスト不足は派生不可なら
return if !@action_data[2] && [email protected]_cost_payable?($data_skills[@action_data[3]])
# 派生
@derivation_skill_id = @action_data[3]
# 以降のアクションをキャンセル
@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 [email protected]
  end
  #--------------------------------------------------------------------------
  # ● 被クリティカルフラグを取得
  #--------------------------------------------------------------------------
  def critical?
return @battler.result.critical
  end
  #--------------------------------------------------------------------------
  # ● 被回復フラグを取得
  #--------------------------------------------------------------------------
  def recovery?
recovery = false
recovery = true if @battler.result.hp_damage < 0
recovery = true if @battler.result.mp_damage < 0
recovery = true if @battler.result.tp_damage < 0
return recovery
  end
  #--------------------------------------------------------------------------
  # ● 被スキルIDを取得
  #--------------------------------------------------------------------------
  def damage_skill_id
return @damage_skill_id
  end
  #--------------------------------------------------------------------------
  # ● 被アイテムIDを取得
  #--------------------------------------------------------------------------
  def damage_item_id
return @damage_item_id
  end
  #--------------------------------------------------------------------------
  # ● 装備武器を取得
  #--------------------------------------------------------------------------
  def weapon_id
return 0 if [email protected][0]
return @battler.weapons[0].id
  end
  #--------------------------------------------------------------------------
  # ● 装備武器のタイプを取得
  #--------------------------------------------------------------------------
  def weapon_type
return 0 if [email protected][0]
return @battler.weapons[0].wtype_id
  end
  #--------------------------------------------------------------------------
  # ● 盾を装備しているか
  #--------------------------------------------------------------------------
  def shield?
for armor in @battler.armors do return true if armor != nil && armor.etype_id == 1 end
return false
  end
  #--------------------------------------------------------------------------
  # ● ダメージがあるか
  #--------------------------------------------------------------------------
  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.sv.base_x if !horming
   y += targets.sv.base_y if !horming
   h += targets.sv.base_h if !horming
   x += targets.sv.x if horming
   y += targets.sv.y if horming
   h += targets.sv.h if horming
   y -= targets.sv.ch * 100 if m_a == 0
   y -= targets.sv.ch * 50 if m_a == 1
end
return [x / targets.size, y / targets.size, h / targets.size]
  end
  #--------------------------------------------------------------------------
  # ● 速度を時間に変換
  #--------------------------------------------------------------------------
  def self.distanse_calculation(time, target_position, self_position, distanse_move)
return time if !distanse_move
distanse_x = self_position[0] - target_position[0]
distanse_x = target_position[0] - self_position[0] if target_position[0] > self_position[0]
distanse_y = self_position[1] - target_position[1]
distanse_y = target_position[1] - self_position[1] if target_position[1] > self_position[1]
if self_position[2] != nil && target_position[2] != nil
   distanse_h = self_position[2] - target_position[2]
   distanse_h = target_position[2] - self_position[2] if target_position[2] > self_position[2]
else
   distanse_h = 0
end
distanse = [distanse_x, distanse_y, distanse_h].max
return distanse / (time * 100) + 1
  end
  #--------------------------------------------------------------------------
  # ● 放物線移動計算
  #--------------------------------------------------------------------------
  def self.parabola(data, time, size, type = 1)
move_data = data
move_data[0] *= size
move_data[1] *= size
move = []
move_d = []
for i in 0...time / 2
   move = move_data[0]
   move_d = move_data[1]
   move_data[0] = move_data[0] * type / (1 + type)
   move_data[1] = move_data[1] * type / (1 + type)
end
move = move + move_d.reverse!
move.reverse!
adjust = move.inject(0) {|result, item| result + item }
move[move.size - 1] += adjust if data[0] == data[1] && adjust != 0
move.unshift(0) if time % 2 != 0
return move
  end
  #--------------------------------------------------------------------------
  # ● 反転値
  #--------------------------------------------------------------------------
  def self.mirror_num(mirror)
return 1 if !mirror
return -1
  end
  #--------------------------------------------------------------------------
  # ● カメラワーク
  #--------------------------------------------------------------------------
  def self.camera(battler, data)
battler = $game_party.battle_members[0] if !battler
cx = data[2][0] * 100
cy = data[2][1] * 100
return $sv_camera.move(cx, cy, data[3], data[4], true) if data[1] == 6
targets = self.get_targets(data[1], battler)
return if targets == nil or targets == []
position = self.get_targets_position(targets, true)
$sv_camera.move(position[0], position[1] - position[2], data[3], data[4], false)
  end
  #--------------------------------------------------------------------------
  # ● コラプス禁止
  #--------------------------------------------------------------------------
  def self.immortaling
# 全員に不死身付与
for member in $game_party.battle_members + $game_troop.members
   # イベント操作等で不死身設定になっていたら解除を無効にするフラグを立てる
   member.sv.immortal = true if member.state?(N03::IMMORTAL_ID)
   member.add_state(N03::IMMORTAL_ID)
end
return true
  end
  #--------------------------------------------------------------------------
  # ● コラプス許可
  #--------------------------------------------------------------------------
  def self.unimmortaling
# 全員の不死身化解除(イベント等で不死身設定がされていれば除く)
for member in $game_party.battle_members + $game_troop.members
   next if member.dead?
   # 不死身ステートが行動中に解除されていた場合、解除無効を解除
   member.sv.immortal = false if !member.state?(N03::IMMORTAL_ID) && member.sv.immortal
   next member.sv.immortal = false if member.sv.immortal
   member.remove_state(N03::IMMORTAL_ID)
   next if member.hp != 0
   member.add_state(1)
   member.perform_collapse_effect
   member.sv.action_terminate
end
return false
  end
  #--------------------------------------------------------------------------
  # ● スキル派生
  #--------------------------------------------------------------------------
  def self.derived_skill(battler)
battler.force_action(battler.sv.derivation_skill_id, -2)
BattleManager.unshift_action_battlers(battler)
  end
  #--------------------------------------------------------------------------
  # ● ダメージの作成
  #--------------------------------------------------------------------------
  def self.set_damage(battler, hp_damage, mp_damage)
battler.result.hp_damage = hp_damage
battler.result.mp_damage = mp_damage
  end
  #--------------------------------------------------------------------------
  # ● ターゲット生死確認
  #--------------------------------------------------------------------------
  def self.targets_alive?(targets)
return false if targets == []
for target in targets do return true if !target.dead? end
return false
  end
  #--------------------------------------------------------------------------
  # ● ターゲットをセカンドターゲットへ
  #--------------------------------------------------------------------------
  def self.s_targets(battler)
battler.sv.target_battler = battler.sv.second_targets
return battler.sv.second_targets
  end
  #--------------------------------------------------------------------------
  # ● セカンドターゲットをターゲットへ
  #--------------------------------------------------------------------------
  def self.targets_set(battler)
battler.sv.second_targets = battler.current_action.make_targets.compact
battler.sv.target_battler = battler.sv.second_targets
  end
  #--------------------------------------------------------------------------
  # ● 戦闘アニメ実行判定 (対象：画面時は最初のターゲットのみアニメ実行)
  #--------------------------------------------------------------------------
  def self.first_of_all_screen_anime(anime_id, target, targets)
anime = $data_animations[anime_id]
return false if !anime
return true if anime.position != 3
return false if anime.position == 3 && target != targets[0]
targets.delete(target)
target.sv.timing_targets = targets
return true
  end
  #--------------------------------------------------------------------------
  # ● 戦闘不能付加攻撃か
  #--------------------------------------------------------------------------
  def self.dead_attack?(battler, item)
for state in battler.atk_states
   return true if state == battler.death_state_id
end
for effect in item.effects
   return true if effect.code == 21 && effect.data_id == battler.death_state_id
end
return false
  end

end

另外我還發現兩個問題
戰鬥中更換隊員的腳本，換了一次後就不能再同場戰鬥裡更換了
如果想改成能每回合，甚至是隨時更換的話該怎麼做？
腳本在這
http://rpg.blue/thread-250698-2-1.html

還有，我先用4個隊員測試戰鬥中更換隊員
是橫板CP制戰鬥系統，CP條上用各角色的Q板作行動順序
結果我讓輪到行動的角色跟待機的角色換，結果一選擇戰鬥，名稱是[碧軌戰鬥]的腳本就出BUG(而且CP條上的Q板角色也沒有立刻更換)
以下是腳本內容
#==============================================================================
# ■ 碧の軌跡っぽい戦闘システム17_2
# @version 0.28 12/03/08
# @author さば缶
#------------------------------------------------------------------------------
# 　
# ■使い方
# 　★★★★データベースのスキル 001～010が必要です。★★★★
# 　コピーして使ってください。
#
# 攻撃(001)    … 通常攻撃の駆動時間や硬直時間の設定
#                   そのほか、<硬直>や<駆動>が指定されていないスキルは
#                   このスキルの値が使われる
# 防御(002)    … 防御の硬直時間の設定
# 逃走(003)    … 逃走の硬直時間の設定
# 　戦闘開始(004)  … 戦闘開始時の初期待ち時間の設定
# 復活(005)    … 生き返ったときの初期待ち時間の設定
# キャンセル(006)… スキルがキャンセルされた後の待ち時間の設定
# 先制(007)    … 先制したキャラの戦闘開始時の初期待ち時間の設定
#                   "戦闘開始(004)"のかわりに使われる
# 行動不能(008)  … スタンなどで行動不能なときと復帰したとき
#
# 　★★★★グラフィックが必要です。★★★★
# "Graphics/System"をコピーして使ってください。
# また、敵のターゲットを消したい場合はTarget.pngを透明な画像と差し替えてください
# 　
#
# ■スキルやアイテムのメモ欄に書けるもの一覧（詳細は実際のスキルのサンプルで）
# <硬直>       … スキル実行後の待ち時間の計算式
# <駆動>       … スキルが駆動されるまでの待ち時間の計算式
# <駆動msg>    … スキルが駆動待ちになったときに表示するメッセージ
#                   <駆動>があるスキルのみで使われる
# <ステート>    … スキルが駆動待ちの間、自動で付与されるステート
#                   スキル駆動またはキャンセルで解除される
#                   <駆動>があるスキルのみで使われる
# <キャンセル> … スキルを当てた対象のスキル駆動を中断させる
# <キャンセル率>  … <キャンセル>が書いてあるときのみ有効、
#                   この確率でキャンセルがかかる。100%の場合は100
# <キャンセル不可>… このスキルは<キャンセル>されない
# <ディレイコマ数>… スキルを当てた対象を指定のコマ数後ろに下げる
#                   マイナスならその分進める
# <ディレイ率> … <ディレイコマ数>が書いてあるときのみ有効、
#                   この確率でディレイがかかる。100%の場合は100
#
# ■アクターやエネミーのメモ欄に書けるもの一覧
# <キャンセル不可>… このキャラは<キャンセル>されない
# <ディレイ不可>  … このキャラはディレイがかからない
#
#==============================================================================
module Saba
  module Kiseki
# 敵キャラのメモ欄にグラフィック指定がない場合のグラフィック名です。
DEFAULT_MONSTER_GRAPHIC_NAME = "Monster1"

# 敵キャラのメモ欄にグラフィック指定がない場合のインデックス番号です。
DEFAULT_MONSTER_GRAPHIC_INDEX = 3

# 敵キャラのメモ欄にこの文字を入れると、空白をはさんで続く文字がグラフィック名、
# さらに空白をはさんで続く文字がグラフィック内のインデックス番号になります。
GRAPHIC_MARKER = "GRAPHIC"

# 素早さが待ち時間に与える影響力です。0以上の整数を設定してください。単位は%。
# 100 でデフォルト、120でデフォルトの1.2倍、50でデフォルトの半分です。
SPEED_INFLUENCE = 100

# デバッグ表示
# キャラの素早さ偏差値がみれます
DEBUG = false

# 駆動SE
OPERATE_SE_FILE = "Audio/SE/Heal4"
# 駆動SEの音量
OPERATE_SE_VOLUME = 80
# 駆動SEのピッチ
OPERATE_SE_PITCH = 150
  end
end

class Scene_Battle
  include Saba::Kiseki
  #--------------------------------------------------------------------------
  # ● 開始処理
  #--------------------------------------------------------------------------
  alias saba_kiseki_start start
  def start
$game_party.clear_results
calculate_battlers_speed
OrderManager.init_unit
saba_kiseki_start
  end
  #--------------------------------------------------------------------------
  # ○ バトラーの速度偏差値を求めます。
  #--------------------------------------------------------------------------
  def calculate_battlers_speed
battlers = $game_party.battle_members + $game_troop.members

total = 0.0
for battler in battlers
   total += battler.agi
end

mean = total / battlers.size
standard_deviation = 0.0

for battler in battlers
   standard_deviation += (battler.agi - mean) * (battler.agi - mean)
end

standard_deviation /= battlers.size
standard_deviation = Math.sqrt(standard_deviation)
for battler in battlers
   if standard_deviation != 0
      battler.spd = ((battler.agi - mean) / standard_deviation) * 10
   else
      battler.spd = 0
   end
   battler.spd *= (SPEED_INFLUENCE / 100.0)
   battler.spd += 50
   p  battler.name + " 速度:" + battler.agi.to_s + " 偏差値:" + battler.spd.to_i.to_s if DEBUG
end
  end
  #--------------------------------------------------------------------------
  # ● パーティコマンド選択の開始
  #--------------------------------------------------------------------------
  def start_party_command_selection
unless scene_changing?
   refresh_status
   @status_window.unselect
   @status_window.open
   BattleManager.input_start
   top_unit = OrderManager.top_unit
   top_unit.battler.on_turn_start
   refresh_status

   @log_window.display_auto_affected_status(top_unit.battler)
   @log_window.wait_and_clear
   @actor_command_window.close
   @party_command_window.setup
end
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  alias saba_kiseki_battle_update_basic update_basic
  def update_basic
saba_kiseki_battle_update_basic
OrderManager.update
  end
  #--------------------------------------------------------------------------
  # ● スキルウィンドウの作成
  #--------------------------------------------------------------------------
  alias saba_kiseki_battle_create_skill_window create_skill_window
  def create_skill_window
saba_kiseki_battle_create_skill_window
@skill_window.set_handler(:change, method(:update_forecast))
  end
  #--------------------------------------------------------------------------
  # ● アイテムウィンドウの作成
  #--------------------------------------------------------------------------
  alias saba_kiseki_battle_create_item_window create_item_window
  def create_item_window
saba_kiseki_battle_create_item_window
@item_window.set_handler(:change, method(:update_forecast))
  end
  #--------------------------------------------------------------------------
  # ● アクターコマンドウィンドウの作成
  #--------------------------------------------------------------------------
  alias saba_kiseki_battle_create_actor_command_window create_actor_command_window
  def create_actor_command_window
saba_kiseki_battle_create_actor_command_window
@actor_command_window.set_handler(:change, method(:update_forecast))
  end
  #--------------------------------------------------------------------------
  # ● アクターウィンドウの作成
  #--------------------------------------------------------------------------
  alias saba_kiseki_battle_create_actor_window create_actor_window
  def create_actor_window
saba_kiseki_battle_create_actor_window
@actor_window.set_handler(:change, method(:update_selection))
  end
  #--------------------------------------------------------------------------
  # ● 敵キャラウィンドウの作成
  #--------------------------------------------------------------------------
  alias saba_kiseki_battle_create_enemy_window create_enemy_window
  def create_enemy_window
saba_kiseki_battle_create_enemy_window
@enemy_window.set_handler(:change, method(:update_selection))
  end
  #--------------------------------------------------------------------------
  # ○ 選択状態の更新
  #--------------------------------------------------------------------------
  def update_selection
OrderManager.clear_selection
OrderManager.select(@enemy_window.enemy) if @enemy_window.active
OrderManager.select(@actor_window.actor) if @actor_window.active
  end
  #--------------------------------------------------------------------------
  # ○ 順番予測更新
  #--------------------------------------------------------------------------
  def update_forecast
OrderManager.clear_selection
actor = BattleManager.actor
case @actor_command_window.current_symbol
   when :attack
      item = $data_skills[actor.attack_skill_id]
   when :guard
      item = $data_skills[actor.guard_skill_id]
   when :skill
      item = @skill_window.item if @skill_window.visible
   when :item
      item = @item_window.item if @item_window.visible
   when :escape
      item = $data_skills[6]
end
return OrderManager.remove_forecast_unit if item == nil
update_forecast_item(item)
  end
  #--------------------------------------------------------------------------
  # ○ 指定のアイテムの順番予測更新
  #--------------------------------------------------------------------------
  def update_forecast_item(item)
battler = OrderManager.top_unit.battler
item = $data_skills[battler.attack_skill_id] if item == nil
operate_time = item.operate_time(battler)
unit = OrderManager.forecast_unit
return if unit && unit.battler == battler && unit.usable_item == item

OrderManager.remove_forecast_unit

if operate_time > 0 && ! OrderManager.top_unit.operate
   if battler.state_operate_time == nil
      OrderManager.insert(battler, operate_time, true, item, true)
   else
      OrderManager.insert(battler, battler.state_operate_time, true, item, true)
   end
   OrderManager.show_targeted(battler) if battler.enemy?
else
   if battler.state_stiff_time == nil
      stiff_time = item.stiff_time(battler)
      OrderManager.insert(battler, stiff_time, true, item)
   else
      OrderManager.insert(battler, battler.state_stiff_time, true, item)
   end
end
  end
  #--------------------------------------------------------------------------
  # ● ターン開始
  #--------------------------------------------------------------------------
  alias saba_kiski_battle_turn_start turn_start
  def turn_start
OrderManager.clear_selection
battler = OrderManager.top_unit.battler

$game_troop.clear_results
$game_party.clear_results

if battler.current_action != nil
   item = battler.current_action.item
   update_forecast_item(item)
else
   update_forecast_item($data_skills[159])
end
saba_kiski_battle_turn_start
if item != nil && item.operate_time(battler) > 0 &&
   OrderManager.top_unit.operate != true
   play_operate_se
   refresh_status
   @log_window.display_prepare_item(battler, item)
end
  end
  #--------------------------------------------------------------------------
  # ○ 駆動SE再生
  #--------------------------------------------------------------------------
  def play_operate_se
Audio.se_play(OPERATE_SE_FILE, OPERATE_SE_VOLUME, OPERATE_SE_PITCH)
  end
  #--------------------------------------------------------------------------
  # ● ターン終了
  #--------------------------------------------------------------------------
  def turn_end
all_battle_members.each do |battler|
   battler.on_turn_end
   if battler.result.status_affected?
      refresh_status
      @log_window.display_auto_affected_status(battler)
      @log_window.wait_and_clear
   end
end
BattleManager.turn_end
process_event
start_party_command_selection
calculate_battlers_speed
  end
  #--------------------------------------------------------------------------
  # ● スキル／アイテムの使用
  #--------------------------------------------------------------------------
  alias saba_kiski_battle_use_item use_item
  def use_item
saba_kiski_battle_use_item
return if @subject.current_action == nil
targets = @subject.current_action.make_targets.compact
targets.each do |target|
   delay = target.result.delay_count
   if delay != 0
      OrderManager.delay_order(target, delay)
      #@log_window.display_delay(target, delay)
   end
   unit = OrderManager.find_unit(target)
   if unit && unit.cancel?
      unit.battler.turn_count += 1
      OrderManager.cancel(unit)
   end
end
  end
  #--------------------------------------------------------------------------
  # ● 戦闘行動終了時の処理
  #--------------------------------------------------------------------------
  alias saba_kiski_battle_process_action_end process_action_end
  def process_action_end
OrderManager.update_delay_time
if BattleManager.battle_end?
   OrderManager.remove_forecast_unit
end
saba_kiski_battle_process_action_end
  end
end

class Window_ActorCommand
  def cancel_enabled?
return false
  end
end

class Spriteset_Battle
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  alias saba_kiseki_battle_initialize initialize
  def initialize
@battle_units = {}
saba_kiseki_battle_initialize
@viewport3.rect.height = Saba::Kiseki::ORDER_BAR_HEIGHT
@kiseki_sprite = Spriteset_Kiseki.new(@viewport3)
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  alias saba_kiseki_battle_update update
  def update
saba_kiseki_battle_update
update_battle_unit
@kiseki_sprite.update if @kiseki_sprite
  end
  #--------------------------------------------------------------------------
  # ○ ユニット更新
  #--------------------------------------------------------------------------
  def update_battle_unit
remove_list = @battle_units.keys
OrderManager.units.each do |unit|
   if @battle_units[unit] == nil
      @battle_units[unit] = Spriteset_BattleUnit.new(@viewport3, unit)
   else
      remove_list.delete(unit)
   end
   @battle_units[unit].update
end
remove_list.each { |unit|
   sprite = @battle_units[unit]
   sprite.dispose
   @battle_units.delete(unit)
}
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  alias saba_kiseki_battle_dispose dispose
  def dispose
@battle_units.values.each { |sprite| sprite.dispose }
@kiseki_sprite.dispose
saba_kiseki_battle_dispose
  end
end

class Window_Selectable
  #--------------------------------------------------------------------------
  # ● 項目の選択
  #--------------------------------------------------------------------------
  alias saba_kiseki_battle_select select
  def select(index)
saba_kiseki_battle_select(index)
call_handler(:change)
  end
  #--------------------------------------------------------------------------
  # ● ウィンドウのアクティブ化
  #--------------------------------------------------------------------------
  def activate
super
call_handler(:change)
self
  end
end

class Game_ActionResult
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :delay_count
  attr_accessor :cancel
  attr_accessor :fail_cancel
  attr_accessor :anti_cancel
  attr_accessor :fail_delay
  attr_accessor :anti_delay
  #--------------------------------------------------------------------------
  # ● クリア
  #--------------------------------------------------------------------------
  alias saba_kiseki_battle_clear clear
  def clear
saba_kiseki_battle_clear
@delay_count = 0
@cancel = false
@fail_cancel = false
@anti_cancel = false
@fail_delay = false
@anti_delay = false
  end
end

class Game_Battler
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :spd
  attr_accessor :turn_count
  alias saba_kiseki_initialize initialize
  def initialize
saba_kiseki_initialize
@spd = 50
@turn_count = 0
  end
  #--------------------------------------------------------------------------
  # ● スキル／アイテムの効果適用
  #--------------------------------------------------------------------------
  alias saba_kiseki_battle_item_apply item_apply
  def item_apply(user, item)
saba_kiseki_battle_item_apply(user, item)
return unless $game_party.in_battle
if @result.hit?

   if user.actor? && item.is_a?(RPG::Skill) && item.id == 1
      # 通常攻撃
      total = 0
      cancel = false
      cancel_attack = false
      delay_attack = false

      user.weapons.each do |weapon|
      total += weapon.delay_count(user)
      delay_attack |= weapon.delay_attack?
      cancel |= weapon.cancel?
      cancel_attack |= weapon.cancel_attack?
      end
      @result.delay_count = total
      @result.cancel = cancel
   else
      @result.delay_count = item.delay_count(user)
      delay_attack = item.delay_attack?
      @result.cancel = item.cancel?
      cancel_attack = item.cancel_attack?
   end
   char = actor? ? actor : enemy
   @result.delay_count = 0 if char.anti_delay?
   if @result.delay_count > 0
      @result.delay_count = [@result.delay_count, OrderManager.max_delay_count(self)].min
   elsif @result.delay_count < 0
      @result.delay_count = [@result.delay_count, OrderManager.min_delay_count(self)].max
   elsif delay_attack
      if char.anti_delay?
      @result.anti_delay = true
      else
      @result.fail_delay = true
      end
   end

   unit = OrderManager.find_unit(self)

   if unit && unit.operate
      # 行動不能によるキャンセルチェック
      if ! self.movable? || self.confusion?
      @result.cancel = true
      elsif char.anti_cancel? || unit.usable_item.anti_cancel?
      # キャンセルが無効化された
      @result.anti_cancel = true if cancel_attack
      @result.cancel = false
      elsif cancel_attack && ! @result.cancel
      # キャンセル失敗
      @result.fail_cancel = true
      @result.cancel = false
      end

   else
      # もともと準備中でない
      @result.cancel = false
   end


   if self.dead?
      @result.anti_delay = false
      @result.fail_delay = false
      @result.delay_count = 0
      @result.cancel = false
      @result.anti_cancel = false
      @result.fail_cancel = false
   end

   @result.success = true if @result.delay_count != 0 || @result.cancel
end
  end
  #--------------------------------------------------------------------------
  # ○ ターン開始処理
  #--------------------------------------------------------------------------
  def on_turn_start
regenerate_all
update_state_turns
update_buff_turns
remove_states_auto(2)
remove_buffs_auto
make_actions
  end
  #--------------------------------------------------------------------------
  # ● ターン終了処理
  #--------------------------------------------------------------------------
  def on_turn_end
@result.clear
  end
  #--------------------------------------------------------------------------
  # ● 戦闘行動終了時の処理
  #--------------------------------------------------------------------------
  def on_action_end
@result.clear
remove_states_auto(1)
@turn_count += 1
  end
  #--------------------------------------------------------------------------
  # ○ ステートによる駆動時間を取得
  #--------------------------------------------------------------------------
  def state_operate_time
n = nil
states.reverse.each do |state|
   if state.operate_formula
      n = state.operate_time(self)
   end
end
return n
  end
  #--------------------------------------------------------------------------
  # ○ ステートによる硬直時間を取得
  #--------------------------------------------------------------------------
  def state_stiff_time
n = nil
states.reverse.each do |state|
   if state.stiff_formula
      n = state.stiff_time(self)
   end
end
return n
  end
end

class << BattleManager
  #--------------------------------------------------------------------------
  # ● 次のコマンド入力へ
  #--------------------------------------------------------------------------
  def next_command
begin
   if !actor || !actor.next_command
      battler = OrderManager.top_unit.battler
      unless battler.actor?
      unless battler.current_action
         OrderManager.top_unit.usable_item = $data_skills[1]
         return false
      end
      OrderManager.top_unit.usable_item = battler.current_action.item
      return false
      end
      return false if @actor_index == battler.index
      @actor_index = battler.index
      if OrderManager.top_unit.operate  # 発動
      OrderManager.top_unit.remove_operate_state
      battler.current_action.set_usable_item(OrderManager.top_unit.usable_item)
      return false
      end
      return false if @actor_index >= $game_party.members.size
   end
end until actor.inputable?
return true
  end
  #--------------------------------------------------------------------------
  # ● 行動順序の作成
  #--------------------------------------------------------------------------
  def make_action_orders
battler = OrderManager.top_unit.battler
if battler.current_action == nil || battler.current_action.item == nil
   @action_battlers = [battler]
elsif battler.current_action.item.operate_time(battler) > 0 &&
   OrderManager.top_unit.operate != true
   # 発動待ち
   OrderManager.top_unit.usable_item = battler.current_action.item
   OrderManager.top_unit.add_operate_state
   @action_battlers = []
else
   @action_battlers = [battler]
end
  end
  #--------------------------------------------------------------------------
  # ● ターン終了
  #--------------------------------------------------------------------------
  alias saba_kiseki_battle_turn_end turn_end
  def turn_end
saba_kiseki_battle_turn_end
unit = OrderManager.top_unit
OrderManager.clear_forecast
OrderManager.update_top
  end
end

class Game_Enemy
  #--------------------------------------------------------------------------
  # ● 戦闘行動の作成
  #--------------------------------------------------------------------------
  alias saba_kiseki_battke_make_actions make_actions
  def make_actions
# 発動待ちを上書きしないように
unit = OrderManager.find_unit(self)
if unit && unit.operate
   return
end
saba_kiseki_battke_make_actions
  end
  #--------------------------------------------------------------------------
  # ● 行動条件合致判定［ターン数］
  #--------------------------------------------------------------------------
  def conditions_met_turns?(param1, param2)
n = @turn_count
#p name + " " + @turn_count.to_s
if param2 == 0
   n == param1
else
   n > 0 && n >= param1 && n % param2 == param1 % param2
end
  end
end

class Game_Actor
  #--------------------------------------------------------------------------
  # ● 戦闘行動の作成
  #--------------------------------------------------------------------------
  alias saba_kiseki_battke_make_actions make_actions
  def make_actions
# 発動待ちを上書きしないように
unit = OrderManager.find_unit(self)
if unit && unit.operate
   return
end
saba_kiseki_battke_make_actions
  end
end

class Window_BattleActor
  #--------------------------------------------------------------------------
  # ○ 味方キャラオブジェクト取得
  #--------------------------------------------------------------------------
  def actor
$game_party.battle_members[@index]
  end
end

class << BattleManager
  attr_reader :preemptive
  attr_reader :surprise
  attr_reader :phase
  def battle_end?
return true if $game_party.members.empty?
return true if $game_party.all_dead?
return true if $game_troop.all_dead?
return true if aborting?
return false
  end
end

class Game_Action
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :targets
  attr_accessor :save_targets
  #--------------------------------------------------------------------------
  # ● クリア
  #--------------------------------------------------------------------------
  alias saba_kiseki_battle_clear clear
  def clear
saba_kiseki_battle_clear
@targets = nil
save_targets = false
  end
  #--------------------------------------------------------------------------
  # ● ターゲットの配列作成
  #--------------------------------------------------------------------------
  alias saba_kiseki_battle_make_targets make_targets
  def make_targets
return @targets if @targets && @save_targets
@targets = saba_kiseki_battle_make_targets
return @targets
  end
  #--------------------------------------------------------------------------
  # ● アイテムを設定
  #--------------------------------------------------------------------------
  def set_usable_item(item)
@item.object = item
self
  end
end

#==============================================================================
# ■ Game_BattleUnit
#------------------------------------------------------------------------------
# 　画面上に表示されるコマです。
#==============================================================================
class Game_BattleUnit
  attr_accessor :battler
  attr_accessor :forecast
  attr_accessor :usable_item
  attr_accessor :operate
  attr_accessor :delay_time          # 待ち時間
  attr_accessor :delay_time_decimal # 待ち時間の小数
  attr_accessor :x
  attr_accessor :dest_y
  attr_accessor :selected
  attr_accessor :targeted
  attr_reader :y
  #--------------------------------------------------------------------------
  # ○ オブジェクトを初期化します。
  #  init_battler このユニットが表すバトラーオブジェクト
  #  delay_time 行動までの待ち時間
  #  forecast 行動の予想ユニットかどうかのフラグ
  #  skill スキルの発動待ちかどうかのフラグ
  #--------------------------------------------------------------------------
  def initialize(battler, delay_time, forecast = false, usable_item = nil, operate = false)
@battler = battler
@delay_time = delay_time
@usable_item = usable_item
@forecast = forecast
@operate = operate
@dest_x = 0
@dest_y = 0
@speed_y = 1
@delay_time_decimal = 0
@x = @dest_x
@y = 0
@targeted = false
@selected = false
  end
  #--------------------------------------------------------------------------
  # ○ 座標を更新
  #--------------------------------------------------------------------------
  def update
update_x
update_y
  end
  #--------------------------------------------------------------------------
  # ○ x 座標を更新
  #--------------------------------------------------------------------------
  def update_x
@x = @dest_x if (@dest_x - @x).abs < 4
@x += 4 if @dest_x > @x
@x -= 4 if @dest_x < @x
  end
  #--------------------------------------------------------------------------
  # ○ y 座標を更新
  #--------------------------------------------------------------------------
  def update_y
if (@dest_y - @y).abs < 3
   @y = @dest_y
   @speed_y = 1
else
   @speed_y = 3
end
@y += @speed_y if @dest_y > @y
@y -= @speed_y if @dest_y < @y
  end
  #--------------------------------------------------------------------------
  # ○ キャンセル
  #--------------------------------------------------------------------------
  def cancel
if @operate && @usable_item
   @operate = false
   remove_operate_state
   return true
else
   return false
end
  end
  #--------------------------------------------------------------------------
  # ○ キャンセルチェック
  #--------------------------------------------------------------------------
  def cancel?
return @battler.result.cancel
  end
  #--------------------------------------------------------------------------
  # ○ 他のユニットと待ち時間を比較するための値を返します。
  # 他のユニット同一の値だと、ソート時に順番が入れ替わるおそれがあるので、
  # バトラー別に補正を掛けます。
  #--------------------------------------------------------------------------
  def delay_time_compare
return -1 if @delay_time == 0 && @forecast #即時効果
return @delay_time * 10000 + delay_time_decimal
  end
  def delay_time_decimal
return 4999 if @forecast
return @delay_time_decimal
  end
  #--------------------------------------------------------------------------
  # ○ 待ち時間を設定
  #--------------------------------------------------------------------------
  def delay_time=(value)
@delay_time = value.round
  end
  #--------------------------------------------------------------------------
  # ○ 順番を設定
  #--------------------------------------------------------------------------
  def index=(arg)
@index = arg
@dest_y = arg * Saba::Kiseki::UNIT_INTERVAL
@dest_y += Saba::Kiseki::MARGIN_CURRENT_BOTTOM if @index > 0
init_position if @x != 0
  end
  #--------------------------------------------------------------------------
  # ○ 座標を初期化
  #--------------------------------------------------------------------------
  def init_position
@y = @dest_y
  end
  #--------------------------------------------------------------------------
  # ○ 待ち時間に自動でかかるステートを設定
  #--------------------------------------------------------------------------
  def add_operate_state
@usable_item.operate_states.each {|s|
   operate_state_targets.each { |b|
      b.add_state(s)
   }
}
  end
  #--------------------------------------------------------------------------
  # ○ 待ち時間に自動でかかるステートを削除
  #--------------------------------------------------------------------------
  def remove_operate_state
@usable_item.operate_states.each {|s|
   operate_state_targets.each { |b|
      b.remove_state(s)
   }
}
  end
  #--------------------------------------------------------------------------
  # ○ 待ち時間に自動でかかるステート対象を取得
  #--------------------------------------------------------------------------
  def operate_state_targets
targets = []
if @usable_item.operate_states_for_friends_all?
   targets += @battler.friends_unit.alive_members
end
if @usable_item.operate_states_for_opponents_all?
   targets += @battler.opponents_unit.alive_members
end
targets = [@battler] if targets.empty?
return targets
  end
  #--------------------------------------------------------------------------
  # ○ 攻撃対象を取得
  #--------------------------------------------------------------------------
  def targets
return [] unless @operate
battler.current_action.save_targets = true
battler.current_action.make_targets
  end
end

class RPG::BaseItem
  #--------------------------------------------------------------------------
  # ○ 駆動時間の取得
  #--------------------------------------------------------------------------
  def operate_time(battler)
operate_formula
return 0 if @operate_formula == nil
a = battler
c = $game_variables
return eval(@operate_formula).to_i
  end
  #--------------------------------------------------------------------------
  # ○ 駆動時間計算式の取得
  #--------------------------------------------------------------------------
  def operate_formula
return @operate_formula if @get_operate_formula
@get_operate_formula = true
self.note.split(/[\r\n]+/).each do |line|
   if line.index("<驱动>") == 0
      @operate_formula = line["<驱动>".length..-1]
      return @operate_formula
   end
end
return nil if self.is_a?(RPG::State)
@operate_formula = $data_skills[1].operate_formula
  end
  #--------------------------------------------------------------------------
  # ○ 硬直時間の取得
  #--------------------------------------------------------------------------
  def stiff_time(battler)
stiff_formula
return 0 if @stiff_formula == nil
a = battler
c = $game_variables
return eval(@stiff_formula)
  end
  #--------------------------------------------------------------------------
  # ○ 硬直時間計算式の取得
  #--------------------------------------------------------------------------
  def stiff_formula
return @stiff_formula if @get_stiff_formula
@get_stiff_formula = true
self.note.split(/[\r\n]+/).each do |line|
   if line.index("<硬直>") == 0
      @stiff_formula = line["<硬直>".length..-1]
      return @stiff_formula
   end
end
return nil if self.is_a?(RPG::State)
@stiff_formula = $data_skills[1].stiff_formula
  end
  #--------------------------------------------------------------------------
  # ○ ディレイ攻撃か？
  #--------------------------------------------------------------------------
  def delay_attack?
return delay_formula != nil
  end
  #--------------------------------------------------------------------------
  # ○ ディレイ値の取得
  #--------------------------------------------------------------------------
  def delay_count(battler)
delay_formula
return 0 if @delay_formula == nil
a = battler
c = $game_variables
ret = eval(@delay_formula)
ret = 0 if rand(100)+1 > delay_percent(battler)
return ret
  end
  #--------------------------------------------------------------------------
  # ○ ディレイ値計算式の取得
  #--------------------------------------------------------------------------
  def delay_formula
return @delay_formula if @get_delay_formula
@get_delay_formula = true
self.note.split(/[\r\n]+/).each do |line|
   if line.index("<延迟数>") == 0
      @delay_formula = line["<延迟数>".length..-1]
      return @delay_formula
   end
   if line.index("<延迟>") == 0
      @delay_formula = line["<延迟>".length..-1]
      return @delay_formula
   end
end
@delay_formula = $data_skills[1].delay_formula
return @delay_formula
  end
  #--------------------------------------------------------------------------
  # ○ ディレイ率の取得
  #--------------------------------------------------------------------------
  def delay_percent(battler)
delay_percent_formula
return 100 if @delay_percent_formula == nil
a = battler
c = $game_variables
return eval(@delay_percent_formula)
  end
  #--------------------------------------------------------------------------
  # ○ ディレイ率計算式の取得
  #--------------------------------------------------------------------------
  def delay_percent_formula
return @delay_percent_formula if @get_delay_percent_formula
@get_delay_percent_formula = true
self.note.split(/[\r\n]+/).each do |line|
   if line.index("<延迟率>") == 0
      @delay_percent_formula = line["<延迟率>".length..-1]
      return @delay_percent_formula
   end
end
return @delay_percent_formula
  end
  #--------------------------------------------------------------------------
  # ○ キャンセル攻撃か？
  #--------------------------------------------------------------------------
  def cancel_attack?
return note.include?("<キャンセル>")
  end
  #--------------------------------------------------------------------------
  # ○ キャンセル攻撃発動か？
  #--------------------------------------------------------------------------
  def cancel?
return false if rand(100)+1 >= cancel_percent
return cancel_attack?
  end
  #--------------------------------------------------------------------------
  # ○ キャンセル率の取得
  #--------------------------------------------------------------------------
  def cancel_percent
cancel_percent_formula
return 100 if @cancel_percent_formula == nil
c = $game_variables
return eval(@cancel_percent_formula)
  end
  #--------------------------------------------------------------------------
  # ○ キャンセル率計算式の取得
  #--------------------------------------------------------------------------
  def cancel_percent_formula
return @cancel_percent_formula if @get_cancel_percent_formula
@get_cancel_percent_formula = true
self.note.split(/[\r\n]+/).each do |line|
   if line.index("<取消率>") == 0
      @cancel_percent_formula = line["<取消率>".length..-1]
      return @cancel_percent_formula
   end
end
return @cancel_percent_formula
  end
  #--------------------------------------------------------------------------
  # ○ ディレイ無効か？
  #--------------------------------------------------------------------------
  def anti_delay?
return note.include?("<无延迟>")
  end
  #--------------------------------------------------------------------------
  # ○ キャンセル不可か？
  #--------------------------------------------------------------------------
  def anti_cancel?
return note.include?("<无法取消>")
  end
  #--------------------------------------------------------------------------
  # ○ 駆動待ちに自動でかかるステートリスト取得
  #--------------------------------------------------------------------------
  def operate_states
return @operate_states if @operate_states
self.note.split(/[\r\n]+/).each do |line|
   if line.index("<状态>") == 0
      @operate_states = line["<状态>".length..-1].split(",").collect { |s| s.to_i }
      return @operate_states
   end
end
@operate_states = []
return @operate_states
  end
  #--------------------------------------------------------------------------
  # ○ 駆動待ちに自動でかかるステート対象が味方全体を含むか？
  #--------------------------------------------------------------------------
  def operate_states_for_opponents_all?
self.note.split(/[\r\n]+/).each do |line|
   if line.index("<ステート対象>") == 0
      return line.include?("敵全体")
   end
end
return false
  end
  #--------------------------------------------------------------------------
  # ○ 駆動待ちに自動でかかるステート対象が敵全体を含むか？
  #--------------------------------------------------------------------------
  def operate_states_for_friends_all?
self.note.split(/[\r\n]+/).each do |line|
   if line.index("<ステート対象>") == 0
      return line.include?("味方全体")
   end
end
return false
  end

end

如果更換非正在行動的角色就沒出現BUG(雖然CP條也沒有立刻更新)
不過等進入下一場戰鬥後，遊戲就當掉了
-------------------
以上
該如何解決這些問題？謝謝

vince3725 · 发表于 2012-10-26 16:48:20

本帖最后由 vince3725 于 2012-10-26 16:51 编辑

你没有在横版脚本里设定第6人的坐标.所以才会出现nilclass.
同理:第五人就要第五人的坐标。。。。以此类推.....

帐号		自动登录	找回密码
密码			注册会员

[已经解决] 橫板戰鬥出BUG了，該怎麼修改？(VA)

加入我们，或者，欢迎回来。

点评

点评

点评

点评

点评

开拓者