SideView Battle 1.2 (Download version 2.3!), Feature Options

[TheJoan]

Hello!

I found a script on RPG Tankentai RPG探検隊, I hope I can post it here.

First of all, you have to create a character set with only one character (a 96*128 image).

Before importing this resource in the graphic folder, be sure to put a $ above the name, otherwise the logiciel will create problem in reckonising the sheet.

Copy these 3 codes before Main:

[Show/Hide] Code1

CODE

#==============================================================================
# ■ module n01 ver1.2
#------------------------------------------------------------------------------
# 　サイドビューバトルのカスタマイズ項目です。
#==============================================================================
module N01
#--------------------------------------------------------------------------
# ● セッティング
#--------------------------------------------------------------------------
  # ゲーム画面の解像度(独自に変更している場合)
  GAME_SCREEN = [544, 416]
  # アクター初期位置　一人目    二人目    三人目    四人目
  #                  X軸 Y軸   X軸 Y軸   X軸 Y軸   X軸 Y軸
  ACTOR_POSITION = [[415,120],[435,150],[455,180],[475,210]]
  # 戦闘メンバー最大数　多人数パーティスクリプト等で増えた時専用
  # 上の初期位置も人数分用意します(後ろに　,[495,240]　と増やしていく)
  MAX_MEMBER = 4
  
  # 戦闘で行動終了後、次のバトラーが行動開始するまでに挟むウエイト時間
  ACTION_WAIT = 12
  # エネミーのコラプス(撃破時の退場)前に挟むウエイト時間
  COLLAPSE_WAIT = 12
  # 勝利前に挟むウエイト時間
  WIN_WAIT = 70
  
  # バトルフロア(床みたいなの)の位置設定 FLOOR = [ X軸, Y軸,透明度]
  FLOOR = [  0, 96,128]
  # 武器なしで攻撃した場合のヒットアニメID
  NO_WEAPON = 82
  # 二刀流設定  武器二つ装備時の一発当たりのダメージ量を設定します。数値は%
  #          　      通常攻撃  ｽｷﾙ,ｱｲﾃﾑ
  TWO_SWORDS_STYLE = [   50,    100]
  
  # ダメージ数字画像のファイル名(横へ等間隔で0～9と並べたシステムフォルダ内画像)
  DAMAGE_GRAPHICS = "Number+"
  # 回復数字画像のファイル名
  RECOVER_GRAPHICS = "Number-"
  # 数値の文字間隔
  NUM_INTERBAL = -3
  # 数値の表示時間
  NUM_DURATION = 68
  # ダメージウインドウを消し、文字だけ表示させる場合はtrue
  NON_DAMAGE_WINDOW = false
  # ダメージウインドウに表示させる単語。表示させたくない場合は""とします。
  POP_DAMAGE0 = "Aucun effet！"  # ダメージが0の時(数字の0はPOPしません)
  POP_MISS    = "Raté！"  # 攻撃が当たらなかった時　
  POP_EVA     = "Paré！"  # 攻撃を回避した時　
  POP_CRI     = "Critique！"  # クリティカル時
  POP_MP_DAM  = "MP drainé"  # MPのダメージを受けた時
  POP_MP_REC  = "MP regagnés"  # MPが回復した時
  
  # 影グラフィック　利用するならtrueしないならfalse
  SHADOW = true  
  # 歩行グラフィック認識　歩行グラを利用するならtrueしないならfalse
  # falseにした場合、必ずファイルNo1以降を用意し、ファイルNo0は使わないように
  # またNo1以降の画像サイズは統一させる(全キャラ統一ではなくそのキャラで統一)
  WALK_ANIME = true
  # バトラーグラフィックのアニメセル数（横分割数）
  ANIME_PATTERN = 3
  # バトラーグラフィックのアニメ種類数（縦分割数）
  ANIME_KIND = 4
  
  # バックアタック(不意打ち時に画面反転)　利用するならtrueしないならfalse
  BACK_ATTACK = true
  # バックアタックで戦闘背景まで反転させないならfalse
  BACK_ATTACK_NON_BACK_MIRROR = true
  # バックアタック無効化設定  不意打ちに対しても効果を発揮。
  # 全て装備していることが条件で、スキルは取得しているだけで効果を発揮します。
  # バックアタックを無効化する武器ID　表記例) = [1]　複数ある表記例) = [1,2]
  NON_BACK_ATTACK_WEAPONS = []
  # バックアタックを無効化する盾ID
  NON_BACK_ATTACK_ARMOR1 = []
  # バックアタックを無効化する頭防具ID
  NON_BACK_ATTACK_ARMOR2 = []
  # バックアタックを無効化する体防具ID
  NON_BACK_ATTACK_ARMOR3 = []
  # バックアタックを無効化するアクセサリID
  NON_BACK_ATTACK_ARMOR4 = []
  # バックアタックを無効化するスキルID
  NON_BACK_ATTACK_SKILLS = []
  # 必ずバックアタックを発生させるスイッチNo(無効化よりも優先されます)
  BACK_ATTACK_SWITCH = []

#==============================================================================
# ■ 単発アクション
#------------------------------------------------------------------------------
# 　通しアクションに利用するものです。これ単体では意味を持ちません。
#==============================================================================
# ここの単発アクション名同士は、かぶらないようにしてください。
# 通しアクション名とかぶる分には問題ありません。
  ANIME = {
#--------------------------------------------------------------------------
# ● バトラーアニメ設定
#--------------------------------------------------------------------------
  # ファイルNo…利用するグラフィックファイルのナンバー。
  #             アクターの場合、0は歩行グラフィックを参照します。
  #             1以降は"キャラクターグラフィック名+_1"のように_の後のナンバーの
  #             グラフィックを参照します。例)$ラルフ_1　のファイルNoは1
  #             グラフィックは全てキャラクターフォルダから探します。
  #
  # 種類…グラフィックファイルのセルの縦位置。上から0～3と続きます。
  # 速度…アニメの更新速度。数字が低いほど早く更新します。
  # ループ… [0=往復ループ] [1=片道ループ] [2=片道のみでループしない]
  # 待ち…ループしない(2)場合、最後のアニメを表示してからの待ち（ウエイト）時間。
  # 固定…アニメせずに固定する場合、セル番号(横位置)を指定。固定しない通常は-1。
  # Z軸…手前に表示するならプラス。通常は画面下ほど手前に表示されます。
  # 影…影グラフィックを表示するならtrue、しない場合はfalse
  # 武器…武器を表示する場合は武器アクション名を。しない場合は""。
  
  # ﾊﾞﾄﾗｰｱﾆﾒ名      ﾌｧｲﾙNo 種類 速度 ﾙｰﾌﾟ 待ち 固定  Z軸  影  武器
  "待機"            => [ 0,  1,  15,   0,   0,  -1,   0, true,"" ],
  "待機(固定)"      => [ 0,  1,  10,   2,   0,   1,   0, true,"" ],
  "右向き(固定)"    => [ 0,  2,  10,   1,   2,   1,   0, true,"" ],
  "ダメージ"        => [ 0,  3,   4,   2,   0,  -1,   0, true,"" ],
  "戦闘不能"        => [ 0,  3,  10,   1,   8,   0,   0, true,"" ],
  "前進"            => [ 0,  1,   1,   1,   0,  -1,   0, true,"" ],
  "後退"            => [ 0,  2,   2,   1,   0,  -1,   0, true,"" ],
  "手前表示"        => [ 0,  1,   2,   1,   0,  -1, 600, true,"" ],
  "武器振り攻撃"    => [ 0,  1,   1,   2,   0,  -1,   2, true,"縦振り"],
  "武器振り攻撃L"   => [ 0,  1,   1,   2,   0,  -1,   2, true,"縦振りL"],
  "武器振り攻撃遅"  => [ 0,  1,   6,   2,   0,  -1,   2, true,"縦振り"],
  "武器回し下"      => [ 0,  1,   2,   2,   0,  -1,   2, true,"下半回転"],
  "武器回し上"      => [ 0,  1,   2,   2,   0,  -1,   2, true,"上半回転"],
  "武器掲げ"        => [ 0,  1,   2,   2,  28,  -1,   2, true,"掲げ"],
  
#--------------------------------------------------------------------------
# ● 武器アクション　武器グラフィックの動かし方
#--------------------------------------------------------------------------
  # ここで使用する武器アクション名は、上のバトラーアニメ設定でのみ有効です。
  
  # X軸…横に動かす距離。
  # Y軸…縦に動かす距離。
  # Z軸…バトラーより手前に表示するならtrue。
  # 始度…動作前の最初の角度。反時計回りで0～360度。負が時計回り。
  # 終度…動作後の角度。
  # 原点…回転元の原点。[0…中心] [1…左上] [2…右上] [3…左下] [4…右下]
  # 反転…trueにするとグラフィックを反転して表示します。
  # X拡…X軸拡大率、横の拡大率です。1が当倍、2が2倍、0.5が1/2になります。
  # Y拡…Y軸拡大率、縦の拡大率です。1が当倍、2が2倍、0.5が1/2になります。
  # 調X…微調整するX軸。この数字ぶん初期X座標が変化します。
  # 調Y…微調整するY軸。この数字ぶん初期Y座標が変化します。
  # 二刀…二刀流時限定で、左(項目でいうと下)の武器画像を表示するようにします。
  #       二刀流じゃなかった場合はバトラーアニメごと処理を飛ばします。
  
  # 武器ｱｸｼｮﾝ名　　 X軸  Y軸  Z軸  始度 終度 原点 反転  X拡  Y拡  調X  調Y 二刀
  "縦振り"     => [   6,   8,false,-135,  45,  4,false,   1,  1,  -4,  -6,false],
  "縦振りL"    => [   6,   8,false,-135,  45,  4,false,   1,  1,  -4,  -6, true],
  "下半回転"   => [   6,   8,false, 270,  45,  4,false,   1,  1,  -4,  -6,false],
  "上半回転"   => [   6,   8,false,  45,-100,  4,false,   1,  1,  -4,  -6,false],
  "掲げ"       => [   6,  -4,false,  90, -45,  4,false,   1,  1,  -4,  -6,false],

#--------------------------------------------------------------------------
# ● バトラー移動  エネミーのX軸移動は逆計算になります
#--------------------------------------------------------------------------
  # 目標…移動する座標の参照先 [0=自身の現在位置] [1=ターゲット] [2=画面] [3=自身の初期位置]
  # X軸…対象から見たX座標。絶対値は最低でも時間より高く
  # Y軸…対象から見たY座標。絶対値は最低でも時間より高く
  # 時間…移動時間。大きいほど遅い。これを距離で割ったのが1フレーム移動距離です。
  # 加速…正は加速、負は減速。数値分1フレームの移動距離が増減しつづけます。
  # ジャンプ…ジャンプ軌道。正は下、負は上軌道。0はジャンプしません。
  # アニメ…その移動に利用するバトラーアニメ名。

  #                        目標  X軸  Y軸 時間 加速 ｼﾞｬﾝﾌﾟ ｱﾆﾒ
  "移動しない"          => [  0,   0,   0,  1,   0,   0,  "待機(固定)"],
  "戦闘開始前の位置へ"  => [  0,  54,   0,  1,   0,   0,  "前進"],
  "一歩前移動"          => [  3, -32,   0, 18,  -1,   0,  "前進"],
  "一歩後移動"          => [  0,  32,   0,  8,  -1,   0,  "前進"],
  "四人攻撃移動1"       => [  2, 444,  96, 18,  -1,   0,  "前進"],
  "四人攻撃移動2"       => [  2, 444, 212, 18,  -1,   0,  "前進"],
  "四人攻撃移動3"       => [  2, 384,  64, 18,  -1,   0,  "前進"],
  "四人攻撃移動4"       => [  2, 384, 244, 18,  -1,   0,  "前進"],
  "被ダメージ"          => [  0,  32,   0,  4,  -1,   0,  "ダメージ"],
  "押し出す"            => [  0,  12,   0,  1,   1,   0,  "ダメージ"],
  "味方逃走"            => [  0, 300,   0,300,   1,   0,  "後退"],
  "逃走失敗"            => [  0,  48,   0, 16,   1,   0,  "後退"],
  "勝利のジャンプ"      => [  0,   0,   0, 20,   0,  -5,  "前進"],
  "目標移動"            => [  1,   0,   0, 18,  -1,   0,  "前進"],
  "目標高速移動"        => [  1,   0, -12,  8,   0,  -2,  "前進"],
  "目標前移動"          => [  1,  24,   0, 12,  -1,   0,  "前進"],
  "目標前高速移動"      => [  1,  24,   0,  1,   0,   0,  "前進"],
  "目標右前移動"        => [  1,  96,  32, 16,  -1,   0,  "前進"],
  "目標左前移動"        => [  1,  96, -32, 16,  -1,   0,  "前進"],
  "一歩前ジャンプ"      => [  0, -32,   0,  8,  -1,  -4,  "前進"],
  "一歩後ジャンプ"      => [  0,  32,   0,  8,  -1,  -4,  "後退"],
  "目標にジャンプ"      => [  1,  12, -12, 12,  -1,  -6,  "前進"],
  "味方投げ"            => [  0, -24,   0, 16,   0,  -2,  "前進"],
  "踏みつけ"            => [  1,  12, -32, 12,  -1,  -6,  "手前表示"],
  "一歩前ジャンプ叩き"  => [  0, -32,   0, 12,  -1,  -2,  "武器振り攻撃"],
  "前ジャンプ叩き"      => [  1,  12,   0, 12,  -1,  -5,  "武器振り攻撃遅"],
  "後方に払い上げ"      => [  1,  12,   0, 16,   0,  -3,  "武器振り攻撃"],
  "その場ジャンプ叩き"  => [  1,   0,   0, 16,   0,  -5,  "武器振り攻撃"],
  "払い抜け"            => [  1, -96,   0, 16,   2,   0,  "武器振り攻撃"],
  "右払い抜け"          => [  1, -96,  32, 16,   2,   0,  "武器振り攻撃"],
  "左払い抜け"          => [  1, -96, -32, 16,   2,   0,  "武器振り攻撃"],
  "右払い抜け2"         => [  1,-128,  48, 16,   2,   0,  "武器振り攻撃"],
  "左払い抜け2"         => [  1,-128, -48, 16,   2,   0,  "武器振り攻撃"],
  
#--------------------------------------------------------------------------
# ● バトラー浮遊  バトラーを影から離します
#--------------------------------------------------------------------------
  # 判別…判別に使うので、すべて"float"で統一してください。
  # 始高…浮遊開始の高さ。符号が負で影より高く、正だと低くなります。
  # 終高…浮遊終了の高さ。移動系のアクションがあるまでこの高さを維持します。
  # 時間…浮遊にかける時間。
  # アニメ…浮遊に利用するバトラーアニメ名。
  
  #                 　    判別  始高 終高 時間 ｱﾆﾒ
  "低空浮遊中"      => ["float", -22, -20,  2, "待機(固定)"],
  "低空浮遊中2"     => ["float", -20, -18,  2, "待機(固定)"],
  "低空浮遊中3"     => ["float", -18, -20,  2, "待機(固定)"],
  "低空浮遊中4"     => ["float", -20, -22,  2, "待機(固定)"],
  "ジャンプ停止"    => ["float",   0, -80,  4, "待機(固定)"],
  "ジャンプ着地"    => ["float", -80,   0,  4, "待機(固定)"],
  "持ち上げられる"  => ["float",   0, -30,  4, "待機(固定)"],
  
#--------------------------------------------------------------------------
# ● 座標リセット　元の位置に戻る移動設定
#--------------------------------------------------------------------------
  # 判別…判別に使うので、すべて"reset"で統一してください。
  # 時間…戻るのにかける時間。同じ時間でも距離が大きいと移動速度が変わります。
  # 加速…正は加速、負は減速。数値分1フレームの移動距離が増減しつづけます。
  # ジャンプ…ジャンプ軌道。正は下、負は上軌道。0はジャンプしません。
  # アニメ…その移動に利用するバトラーアニメ名を入れます。

  #                 　    判別  時間 加速 ｼﾞｬﾝﾌﾟ ｱﾆﾒ
  "座標リセット"    => ["reset", 16,  0,   0,  "前進"],
  "後退リセット"    => ["reset", 16,  0,   0,  "後退"],
  
#--------------------------------------------------------------------------
# ● 強制アクション　自分以外のバトラーにアクションを取らせます
#--------------------------------------------------------------------------
  # 識別…取らせるアクションが単発か通しか。"単発"はここの単発アクション名を。
  #       "通し"とは単発アクションを組み合わせたものを指します。
  #
  # 対象…アクションを取らせる対象。0はターゲット、それ以外はそのステートNoが
  #       付いているバトラー全部を対象とします。
  #       数値に-マイナスを付けることで、その絶対値のスキルIDを習得している
  #       自分以外のアクターを対象とします(アクター限定)
  #       インデックス(メンバー位置)で指定する場合、インデックス値に1000足します。
  #       指定したインデックスが自分だったり存在しない場合(戦闘不能や逃走)は
  #       0番から順に参照し、誰も該当しなかった時は行動を中断します。
  #
  # 復帰…アクション後位置を戻すなら座標リセット系の単発アクション名を入れます。
  #       戻さない場合""とします。
  # アクション名…強制するアクション名。識別が単発なら、単発アクション名を。
  #               通しなら通しアクション名を。
  
  #                       識別    対象   復帰              アクション名
  "小吹き飛ばし"     => ["単発",    0, "座標リセット",  "押し出す"],
  "右回し"           => ["単発",    0, "座標リセット",  "右回り1回転"],
  "縦にぺしゃんこ"   => ["単発",    0, "座標リセット",  "縦縮み"],
  "着弾1"            => ["単発",    0, "座標リセット",  "対象から自身へ1"],
  "味方持ち上げ"     => ["単発",    0,             "",  "持ち上げられる"],
  "ウルリカと攻撃"   => ["通し",   18, "座標リセット",  "ウルリカ合体攻撃1"],
  "四人で攻撃1"      => ["通し", -101, "座標リセット",  "四人合体攻撃1"],
  "四人で攻撃2"      => ["通し", -102, "座標リセット",  "四人合体攻撃2"],
  "四人で攻撃3"      => ["通し", -103, "座標リセット",  "四人合体攻撃3"],
  "味方投げ飛ばし"   => ["通し", 1000, "座標リセット",  "投げつけられる"],

#--------------------------------------------------------------------------
# ● ターゲット変更  バトラーの現在ターゲットしている対象を変えます
#--------------------------------------------------------------------------
  # ※あくまでスプライトアクション上のターゲットを変えるだけで、戦闘上での
  #   ターゲットは変更されません。戦闘行動中のバトラーだけが実行できます。
  # 判別…判別に使うので、すべて"target"で統一してください。
  #
  # 対象…ターゲットを変更させる対象。0はターゲット、それ以外はそのステートNoが
  #       付いているバトラー全部のターゲットを変えます。
  #       数値を負にすることでその絶対値のスキルIDを習得している味方全員を対象に。
  #       インデックス(メンバー位置)で指定する場合、インデックス値に1000足します。
  #       指定したインデックスが自分だったり存在しない場合(戦闘不能や逃走)は
  #       0番から順に参照します。
  #
  # 変更先…変更先内容   0=自分に  1=自分のターゲットに　
  #                      2=自分のターゲットに変更後、自身のターゲットを変更相手に
  #                      3=変更した自身のターゲットを戻す(事前に2を実行していること)
  
  # ターゲット変更名             判別   対象  変更先
  "標的を自身に"          => ["target",    0,  0],
  "二人攻撃目標統一"      => ["target",   18,  1],
  "四人攻撃目標統一"      => ["target",   19,  1],
  "投げる相手選択"        => ["target", 1000,  2],
  "投げつけ目標セット"    => ["target", 1000,  3],
  
#--------------------------------------------------------------------------
# ● スキル派生 アクションを中断し、別のスキルに派生させます
#--------------------------------------------------------------------------
  # 判別…判別に使うので、すべて"der"で統一してください。
  # 確率…派生する確率、0～100で。派生しなかった場合、残りアクションを続行します。
  # 習得…派生するスキルが未修得でも実行可能ならtrue
  # ｽｷﾙID…派生するスキルのID
  
  # 派生名               判別  確率  習得 ｽｷﾙID
  "ヒールに派生"     => ["der", 100, true,  91],
  "適当に派生"       => ["der", 100, true,  92],

#--------------------------------------------------------------------------
# ● アクション条件  条件を設定し、満たされなかったら以降の全行動を中断します
#--------------------------------------------------------------------------
  # 判別…判別に使うので、すべて"nece"で統一してください。
  # 対象…条件を参照する対象。[0=自分] [1=ターゲット] [2=敵全体] [3=味方全体]
  # 内容… [0=ステート] [1=パラメータ] [2=スイッチ] [3=変数] [4=習得スキル]
  #
  # 条件…上の内容で決めた項目に合致する数値を入れます。
  # [0]ステート…ステートID
  # [1]パラメータ…[0=現HP] [1=現MP] [2=攻撃力] [3=防御力] [4=精神力] [5=敏捷性]
  # [2]スイッチ…ゲーム中のスイッチNo
  # [3]変数…ゲーム中の変数No
  # [4]習得スキル…特定のスキル習得を条件とし、そのスキルIDを指定します。
  #
  # 補足…上の条件補足。
  # [0]ステート…条件となる被ステート人数。
  #              符号が正でかかっている、負でかかっていないことが条件となります。
  # [1]パラメータ…パラメータの数値。対象が複数だと平均を出します。
  #                符号が正で数値以上、負で数値以下が条件となります。
  # [2]スイッチ…スイッチONが条件なら true、OFFが条件なら false
  # [3]変数…符号が正で数値以上、負で数値以下が条件となります。
  # [4]習得スキル…条件となるスキル習得人数。
  
  # 派生名                 判別  対象  内容 条件 補足
  "二人攻撃条件確認"  => ["nece",   3,   0,  18,    1],
  "四人攻撃条件確認"  => ["nece",   3,   0,  19,    3],
  "浮遊ステート確認"  => ["nece",   0,   0,  17,    1],
  "ネコに変身してるか"=> ["nece",   0,   0,  20,    1],
  
#--------------------------------------------------------------------------
# ● バトラー回転　画像を回転。反転と違い、武器アクションは反映されません
#--------------------------------------------------------------------------
  # 判別…判別に使うので、すべて"angle"で統一してください。
  # 時間…回転にかける時間。
  # 始度…回転開始時の角度。0～360度を指定。正が半時計周り、負が時計周り。
  # 終度…回転終了時の角度。0～360度を指定。上記ともにエネミーは逆計算になります。
  # 復帰…trueにすると終了と同時に通常角度に戻る。falseはアクション中そのまま。

  #                 　   判別  時間 始度 終度 復帰
  "倒れたまま"     => ["angle",  1, -90, -90,false],
  "右回り1回転"    => ["angle", 48,   0,-360,false],
  "左高速回転"     => ["angle",  6,   0, 360,false],

#--------------------------------------------------------------------------
# ● バトラー拡大縮小　武器アクションは反映されません
#--------------------------------------------------------------------------
  # 判別…判別に使うので、すべて"zoom"で統一してください。
  # 時間…拡大縮小にかける時間。
  # X拡…横の拡大率。1.0が等倍で、0.5が半分になります。
  # Y拡…縦の拡大率。1.0が等倍で、0.5が半分になります。
  # 復帰…trueにすると終了と同時に等倍に戻ります。falseはそのまま。
  #       拡大縮小中は一時的に転送元原点が変わりますが、この復帰で元に戻ります。

  #                 　 判別  時間  X拡  Y拡  復帰
  "横縮み"         => ["zoom", 16, 0.5, 1.0, true],
  "縦縮み"         => ["zoom", 16, 1.0, 0.5, true],
  
#--------------------------------------------------------------------------
# ● 戦闘アニメ　データベースの戦闘アニメを表示します
#--------------------------------------------------------------------------
  # 判別…判別に使うので、すべて"anime"で統一してください。
  # ID…アニメID。-1で武器やスキルに設定されたアニメになりダメージを表示。
  #     -2にするとスキルでも武器依存のアニメになります。
  # 対象… [0=自分] [1=ターゲット]
  # 反転…trueでアニメ画像が反転されます。
  # ウエイト…アニメ表示が終わるまで待つならtrue。
  # 二刀用…trueで二刀流時限定でアニメを実行。アニメIDを-1にした通常攻撃の場合は
  # 左武器に設定されたアニメを表示します。スキルはスキルアニメを再度実行。
  
  #                       判別      ID 対象  反転  ｳｴｲﾄ  二刀用
  "対象アニメ"        => ["anime",  -1,  1, false,false, false],
  "対象アニメウエイト"=> ["anime",  -1,  1, false, true, false],
  "対象アニメ武器"    => ["anime",  -2,  1, false,false, false],
  "対象アニメL"       => ["anime",  -1,  1, false,false,  true],
  "打撃アニメ"        => ["anime",   1,  1, false,false, false],
  "斬撃/必殺技1"      => ["anime",  11,  1, false,false, false],
  
#--------------------------------------------------------------------------
# ● アニメ飛ばし　戦闘アニメを飛ばします。飛び道具、遠距離攻撃用
#--------------------------------------------------------------------------
  # ID…データベースで設定されているアニメのID。0はアニメを非表示に。
  # 対象…飛ばす対象 [0=ターゲット] [1=敵全体の中心] [2=味方全体の中心] [4=自身]
  # タイプ…[0=当たって消える] [1=直線に貫通]
  # 時間…アニメを飛ばす際の移動時間。大きいほど速度も遅い。
  # 軌道…アニメを飛ばす際の軌道。数値を入れると曲線に。正が下、負が上軌道。
  # 調X…微調整するX軸。飛ばす初期X座標が変化します。エネミーは自動で逆計算に。
  # 調Y…微調整するY軸。飛ばす初期Y座標が変化します。
  # 始…アニメを飛ばす際の開始位置。[0=自身] [1=対象] [2=移動させない]
  # Z座標…アニメや武器をキャラより手前に表示するならtrue
  # 武器…下の貼り付ける武器アクション名を入れます。武器を表示しないなら""
  
  #                     判別   ID 対象 ﾀｲﾌﾟ 時間  軌 調X 調Y 始 Z座標 武器
  "魔法始動アニメ"  => ["m_a", 44,   4,  0,  52,   0,  0,  0, 2,false,""],
  "対象から自身へ1" => ["m_a",  4,   0,  0,  24,   0,  0,  0, 1,false,""],
  "武器投げ開始"    => ["m_a",  0,   0,  0,  18, -24,  0,  0, 0,false,"回転投げ"],
  "武器投げ戻し"    => ["m_a",  0,   0,  0,  18,  24,  0,  0, 1,false,"回転投げ"],
  "全体アニメ単体化"=> ["m_a", 80,   1,  0,  64,   0,  0,  0, 2, true,""],
  
#--------------------------------------------------------------------------
# ● アニメ飛ばしに貼り付ける武器画像アクション　上のアニメ飛ばし専用
#--------------------------------------------------------------------------
  # 貼り付けた武器画像の動き。この画像は武器アクションの画像とは別に設定できます。
  # その場合貼り付ける画像は武器設定で行ってください。
  # 始度…動作前の最初の角度。半時計回りで0～360度。
  # 終度…動作後の角度。半時計回りで0～360度。
  # 時間…回転にかける時間。小さいほど早い。動作は消えるまでループし続けます。
  
  # 武器ｱｸｼｮﾝ名　　  始度 終度 時間
  "回転投げ"     => [   0, 360,  8],
  
#--------------------------------------------------------------------------
# ● ふきだしアニメ　イベントに使うふきだしアイコンを表示
#--------------------------------------------------------------------------
  # 判別…判別に使うので、すべて"balloon"で統一してください。
  # 種類…ふきだしの種類(縦位置)を0～9で指定
  # ﾙｰﾌﾟ…アニメ更新方法で、終了すると消えます。[0=片道] [1=往復]
  
  # ふきだし名　　       判別     種類 ﾙｰﾌﾟ
  "状態異常/汎用"   => ["balloon",   6,  1],
  "状態異常/ピンチ" => ["balloon",   5,  1],
  "状態異常/睡眠"   => ["balloon",   9,  1],
  
#--------------------------------------------------------------------------
# ● サウンドの演奏
#--------------------------------------------------------------------------
  # 判別…判別に使うので、すべて"sound"で統一してください。
  # 種別…効果音は"se"  BGMは"bgm"  BGSは"bgs"
  # ﾋﾟｯﾁ…ピッチ、50～150まで指定。音量…ボリューム　どちらも100がデフォルト。
  # ﾌｧｲﾙ名…再生するファイル名。""にするとBGM、BGSを変えずに各種設定可能。
  
  #   SE名              判別   種別 ﾋﾟｯﾁ 音量  SEﾌｧｲﾙ名
  "absorb1"       => ["sound", "se",  80, 100, "absorb1"],
  
#--------------------------------------------------------------------------
# ● ゲーム全体のスピード変更  アクションの細部チェック用
#--------------------------------------------------------------------------
  # 判別…判別に使うので、すべて"fps"で統一してください。
  # ｹﾞｰﾑｽﾋﾟｰﾄﾞ…60がデフォルトで、低くなるほどスローになります。　
  # ※このコマンドはFPSを直接変更するものです。取り扱いには注意してください。
  # 　またタイマーカウント、ゲーム内時間もその分ズレることになります。
  
  # 変更名           判別  ｹﾞｰﾑｽﾋﾟｰﾄﾞ
  "スロー再生"   => ["fps",  10],
  "通常再生に"   => ["fps",  60],
  
#--------------------------------------------------------------------------
# ● ステート付与
#--------------------------------------------------------------------------
  # 判別…判別に使うので、すべて"sta+"で統一してください。
  # 対象…[0=自分] [1=ターゲット] [2=敵全体] [3=味方全体] [4=自分を除く味方全体]
  # ｽﾃｰﾄID…付与するステートのID。「抵抗しない」ステート以外は抵抗します。
  
  # ステート付与名           判別  対象  ｽﾃｰﾄID
  "二人攻撃ステート付与" => ["sta+",  0,  18],
  "四人攻撃ステート付与" => ["sta+",  0,  19],
  "neko"                 => ["sta+",  0,  20],
  
#--------------------------------------------------------------------------
# ● ステート解除
#--------------------------------------------------------------------------
  # 判別…判別に使うので、すべて"sta-"で統一してください。
  # 対象…[0=自分] [1=ターゲット] [2=敵全体] [3=味方全体] [4=自分を除く味方全体]
  # ｽﾃｰﾄID…解除するステートのID
  
  # ステート付与名           判別  対象  ｽﾃｰﾄID
  "二人攻撃ステート解除" => ["sta-",  3,  18],
  "四人攻撃ステート解除" => ["sta-",  3,  19],

#--------------------------------------------------------------------------
# ● バトラー画像ファイル変更  自身のみアクター限定
#--------------------------------------------------------------------------
  # 判別…判別に使うので、すべて"change"で統一してください。
  # ﾘｾｯﾄ…戦闘後も変更を反映させるならfalse。キャラチップも変わります。
  # ﾌｧｲﾙ名…変更する画像ファイル名。認識先を変えるので"_1"は指定しないように。
  
  # 変更名               判別   ﾘｾｯﾄ  ﾌｧｲﾙ名
  "ネコに変身"    => ["change", true,"$ネコ"],
  "変身解除"      => ["change", true,"$イルヴァ"],
  
#--------------------------------------------------------------------------
# ● ピクチャの表示 バトラー一体につき同時に1枚表示できます
#--------------------------------------------------------------------------
  # 始X…移動開始位置。画面から見たX座標。ピクチャの左上を原点とします。
  # 始Y…移動開始位置。画面から見たY座標。
  # 終X…移動終了X座標。
  # 終Y…移動終了Y座標。
  # 時間…移動時間。大きいほど遅い。これを距離で割ったのが1フレーム移動距離です。
  # Z軸…HPウインドウよりも手前に表示するならtrue
  # ﾋﾟｸﾁｬﾌｧｲﾙ名…ピクチャフォルダ内のファイル名。

  #                       判別   始X  始Y  終X  終Y 時間  Z軸 ﾋﾟｸﾁｬﾌｧｲﾙ名
  "カットイン1始"     => ["pic",-280,  48,   0,  64, 14,false,"Actor2-3"],
  "カットイン1終"     => ["pic",   0,  48, 550,  64, 12,false,"Actor2-3"],
  
#--------------------------------------------------------------------------
# ● ゲームスイッチの操作
#--------------------------------------------------------------------------
  # 判別…判別に使うので、すべて"switch"で統一してください。
  # ｽｲｯﾁNo…何番のスイッチを操作するか
  # ON/OFF…ONにするならtrue、OFFにするならfalse
  #
  # スイッチ操作名          判別   ｽｲｯﾁNo ON/OFF  
  "スイッチNo1/ON"    => ["switch",   1,  true],
  
#--------------------------------------------------------------------------
# ● ゲーム変数の操作
#--------------------------------------------------------------------------
  # 判別…判別に使うので、すべて"variable"で統一してください。
  # 変数No…何番の変数を操作するか
  # 操作…[0=代入] [1=加算] [2=減算] [3=乗算] [4=除算] [5=剰余]
  # ｵﾍﾟﾗﾝﾄﾞ…演算の対象となる数値を指定します。
  #
  # 変数操作名    　　     判別     変数No 操作 ｵﾍﾟﾗﾝﾄﾞ
  "変数No1/+1"       => ["variable",   1,   1,    1],
  
#--------------------------------------------------------------------------
# ● その他　設定項目なし。ここで使われている名称は変更しないでください。
#--------------------------------------------------------------------------
  # ピクチャ消去…表示しているピクチャを消します。
  # 残像ON…バトラーの軌跡に残像を残します。通しアクション中は残像し続けます。
  # 残像OFF…残像を消します。
  # 反転…画像を反転します。再度反転させるか座標リセットしない限り反転したまま。
  # 待機に移行しない…行動後、待機アクションを取らせません。
  # コラプス許可…ターゲットのHPが0になった場合、このタイミングでコラプスを
  #               開始させます。これがなければアクション終了時にコラプスします。
  # 二刀限定…この次の単発アクションのみ、二刀限定で行うようにします。
  #           二刀でなければ処理を飛ばし、次の単発アクションに移行します。
  # 非二刀限定…上とは逆に二刀ではないときのみ次の単発アクションを有効にします。
  # 個別処理開始…全体攻撃を個別で処理する場合の、リピート行動開始の目印です。
  # 個別処理終了…全体攻撃を個別で処理する場合の、リピート行動終了の目印です。
  # 初期位置変更…元の座標(初期位置)を今いる位置に変更します。
  # 初期位置変更解除…初期位置変更で変化した座標を元に戻します。
  # アクティブ解除…戦闘行動が終了したとみなし、直後に次のキャラが行動開始します。
  #                 コラプス許可機能も含んでおり、これ以降ダメージは与えられません。
  # 終了…行動の終了。これは入れなくてもアクションがなくなれば自動で認識します。
  
  "ピクチャ消去"    => ["ピクチャ消去"],
  "残像ON"          => ["残像ON"],
  "残像OFF"         => ["残像OFF"],
  "反転"            => ["反転"],
  "待機に移行しない"=> ["待機に移行しない"],
  "コラプス許可"    => ["コラプス許可"],
  "二刀限定"        => ["二刀限定"],
  "非二刀限定"      => ["非二刀限定"],
  "個別処理開始"    => ["個別処理開始"],
  "個別処理終了"    => ["個別処理終了"],
  "初期位置変更"    => ["初期位置変更"],
  "初期位置変更解除"=> ["初期位置変更解除"],
  "アクティブ解除"  => ["アクティブ解除"],
  "終了"            => ["終了"]
  
#--------------------------------------------------------------------------
# ● ウエイトについて
#--------------------------------------------------------------------------
  # 単発アクションで数値のみの場合、それがそのままウエイト時間となります。
  # つまり単発アクション名に数値のみの名称は使えないので注意してください。
  # ウエイトは次のアクションに行かずに待つ時間ですが、バトラーアニメの更新は
  # 止まらずに行われます。
  
  }
#==============================================================================
# ■ 通しアクション
#------------------------------------------------------------------------------
# 　上の単発アクションを組み合わせたもので、これが実際に取る行動となります
#==============================================================================
  # ここの通しアクション名が下のアクター、エネミー指定アクションに使われます。
  # 行動は左側から順番に行われます。
  ACTION = {
#------------------------------- 待機系 -----------------------------------------  
  # 通しアクション名     行動
  
  "戦闘開始"          => ["戦闘開始前の位置へ","座標リセット"],
                          
  "待機"              => ["待機"],
                          
  "ピンチ待機"        => ["移動しない","待機(固定)","状態異常/ピンチ","22"],
                          
  "状態異常待機"      => ["移動しない","待機(固定)","状態異常/汎用","22"],
                          
  "睡眠待機"          => ["移動しない","待機(固定)","状態異常/睡眠","22"],
                          
  "浮遊待機"          => ["待機(固定)","6","低空浮遊中","4",
                          "低空浮遊中2","4","低空浮遊中3","4",
                          "低空浮遊中4","4"],
                          
  "気絶"              => ["倒れたまま","戦闘不能"],
                          
  "ダメージ"          => ["被ダメージ","座標リセット"],
                          
  "逃走"              => ["味方逃走"],
                          
  "エネミー逃走"      => ["味方逃走","座標リセット"],
                          
  "逃走失敗"          => ["逃走失敗","待機(固定)","8","座標リセット"],
                          
  "コマンド入力"      => ["一歩前移動"],
                          
  "コマンド入力後"    => ["座標リセット"],
                          
  "防御"              => ["待機(固定)","4","浮遊ステート確認","低空浮遊中",
                          "2","低空浮遊中2","2","低空浮遊中3","2",
                          "低空浮遊中4","2"],
                          
  "回避"              => ["一歩後ジャンプ","一歩後ジャンプ","待機(固定)","16",
                          "座標リセット"],
                          
  "エネミー回避"      => ["一歩後ジャンプ","待機(固定)","16","座標リセット"],
                          
  "勝利"              => ["待機(固定)","16","右向き(固定)","勝利のジャンプ",
                          "待機(固定)","待機に移行しない","ネコに変身してるか",
                          "魔法始動アニメ","変身解除","待機(固定)","待機に移行しない",],
                          
  "座標復帰"          => ["座標リセット"],
                          
#------------------------------- 強制系 ----------------------------------------                          
                          
  "ウルリカ合体攻撃1" => ["2","目標左前移動","待機(固定)",
                          "魔法始動アニメ","武器回し下","武器掲げ",
                          "48","右払い抜け","64","後退リセット"],
                          
  "四人合体攻撃1"     => ["2","四人攻撃移動2","待機(固定)","魔法始動アニメ",
                          "武器回し下","武器掲げ","90",
                          "左払い抜け","96","後退リセット"],
                          
  "四人合体攻撃2"     => ["2","四人攻撃移動3","待機(固定)","魔法始動アニメ",
                          "武器回し下","武器掲げ","60","右払い抜け2","右回し",
                          "対象アニメ","128","後退リセット"],
                          
  "四人合体攻撃3"     => ["2","四人攻撃移動4","待機(固定)","魔法始動アニメ",
                          "武器回し下","武器掲げ","34","左払い抜け2","右回し",
                          "対象アニメ","144","後退リセット"],
                          
  "投げつけられる"    => ["右回り1回転","4","目標高速移動","一歩後ジャンプ","4",
                          "待機(固定)","一歩後ジャンプ","待機(固定)","32"],
                          
#--------------------------- 基本アクション系 ----------------------------------
  
  "通常攻撃"          => ["目標前移動","武器振り攻撃","対象アニメウエイト",
                          "16","武器振り攻撃L","対象アニメL","二刀限定","16",
                          "コラプス許可","後退リセット"],
                          
  "敵武器なし攻撃"    => ["目標前移動","武器振り攻撃","対象アニメウエイト",
                           "コラプス許可","後退リセット"],
                          
  "汎用スキル使用"    => ["一歩前移動","待機(固定)","魔法始動アニメ",
                          "武器回し下","武器掲げ","武器振り攻撃",
                          "対象アニメウエイト","コラプス許可","24","座標リセット"],
                          
  "汎用スキル個別処理"=> ["一歩前移動","魔法始動アニメ","武器回し下","武器掲げ",
                          "個別処理開始","武器振り攻撃","対象アニメ","24",
                          "個別処理終了","コラプス許可","座標リセット"],
                          
  "アイテム使用"      => ["目標前移動","待機(固定)","24","対象アニメウエイト",
                          "コラプス許可","座標リセット"],
                          
#------------------------------ スキル系 ---------------------------------------                          
  
  "多段攻撃"          => ["残像ON","前ジャンプ叩き","武器振り攻撃L","対象アニメ武器",
                          "待機(固定)","16","対象アニメ武器","武器回し下",
                          "武器回し上","4","その場ジャンプ叩き","武器振り攻撃L",
                          "対象アニメ武器","待機(固定)","16","対象アニメ武器",
                          "反転","武器振り攻撃","武器振り攻撃L","12","反転",
                          "その場ジャンプ叩き","武器振り攻撃L","対象アニメ武器",
                          "一歩後ジャンプ","一歩後ジャンプ","待機(固定)",
                          "対象アニメ武器","払い抜け","武器振り攻撃L","コラプス許可",
                          "残像OFF","16","後退リセット"],
                          
  "多段攻撃ランダム用"=> ["前ジャンプ叩き","武器振り攻撃L","対象アニメ武器","待機(固定)","16",
                          "前ジャンプ叩き","武器振り攻撃L","対象アニメ武器","待機(固定)","16",
                          "前ジャンプ叩き","武器振り攻撃L","対象アニメ武器","待機(固定)","16",
                          "前ジャンプ叩き","武器振り攻撃L","対象アニメ武器","コラプス許可","座標リセット"],
                          
  "高速多段攻撃"      => ["目標前移動","武器振り攻撃","小吹き飛ばし","対象アニメ武器",
                          "目標前高速移動","武器振り攻撃","小吹き飛ばし","武器振り攻撃L","対象アニメ武器",
                          "目標前高速移動","武器振り攻撃","小吹き飛ばし","武器振り攻撃L","対象アニメ武器",
                          "目標前高速移動","武器振り攻撃","小吹き飛ばし","武器振り攻撃L","対象アニメ武器",
                          "目標前高速移動","武器振り攻撃","小吹き飛ばし","武器振り攻撃L","対象アニメ武器",
                          "目標前高速移動","武器振り攻撃","小吹き飛ばし","武器振り攻撃L","対象アニメ武器",
                          "コラプス許可","12","座標リセット"],
                          
  "二人同時攻撃"      => ["二人攻撃条件確認","二人攻撃目標統一","ウルリカと攻撃",
                          "目標右前移動","待機(固定)","魔法始動アニメ","武器回し下",
                          "武器掲げ","48","斬撃/必殺技1","左払い抜け","64","対象アニメ",
                          "コラプス許可","後退リセット","二人攻撃ステート解除"],
                          
  "二人同時攻撃準備"  => ["二人攻撃ステート付与"],  
                          
  "四人同時攻撃"      => ["四人攻撃条件確認","四人攻撃目標統一","四人で攻撃1",
                          "四人で攻撃2","四人で攻撃3","四人攻撃移動1","待機(固定)",
                          "魔法始動アニメ","武器回し下","武器掲げ","90",
                          "斬撃/必殺技1","右払い抜け","64","対象アニメウエイト",
                          "コラプス許可","後退リセット","合体攻撃解除"],
                          
  "四人同時攻撃準備"  => ["四人攻撃ステート付与"],
                          
  "武器投げ"          => ["一歩前移動","武器振り攻撃","absorb1","待機(固定)",
                          "武器投げ開始","12","対象アニメ武器","コラプス許可",
                          "武器投げ戻し","16","座標リセット"],
                          
  "個別全体遠距離攻撃"=> ["一歩前ジャンプ","ジャンプ停止","個別処理開始",
                          "標的を自身に","武器振り攻撃","着弾1","8",
                          "対象アニメ武器","個別処理終了","コラプス許可",
                          "ジャンプ着地","座標リセット"],
                          
  "全体遠距離攻撃"    => ["標的を自身に","武器振り攻撃","着弾1","20",
                          "対象アニメウエイト","コラプス許可"],
                        
  "ヒールに派生"      => ["目標前移動","対象アニメ","武器振り攻撃",
                          "16","ヒールに派生","座標リセット"],
                          
  "適当に派生"        => ["逃走失敗","魔法始動アニメ","武器回し下","武器掲げ",
                          "8","対象アニメウエイト","16","適当に派生","座標リセット"],
                          
  "カットイン"        => ["待機(固定)","魔法始動アニメ","カットイン1始",
                          "75","カットイン1終","8","目標前移動",
                          "武器振り攻撃","対象アニメウエイト","コラプス許可",
                          "ピクチャ消去","後退リセット"],
                          
  "踏み潰し"          => ["目標にジャンプ","打撃アニメ","縦にぺしゃんこ","一歩後ジャンプ",
                          "踏みつけ","打撃アニメ","縦にぺしゃんこ","一歩後ジャンプ",
                          "踏みつけ","対象アニメ","縦にぺしゃんこ","一歩後ジャンプ",
                          "一歩後ジャンプ","コラプス許可","待機(固定)","8","後退リセット"],
                          
  "全体攻撃1"         => ["一歩前移動","待機(固定)","魔法始動アニメ","武器回し下",
                          "武器掲げ","全体アニメ単体化","武器振り攻撃","48",
                          "対象アニメウエイト","コラプス許可","座標リセット"],
                          
  "ネコに変身"        => ["一歩前ジャンプ","待機(固定)","魔法始動アニメ","32",
                          "ネコに変身","待機(固定)","neko","32","一歩後ジャンプ"],                    
                          
  "味方投げつけ"      => ["投げる相手選択","目標移動","味方持ち上げ","4",
                          "absorb1","投げつけ目標セット","味方投げ飛ばし",
                          "味方投げ","待機(固定)","対象アニメ","座標リセット",
                          "待機(固定)","32"],
                          
                          
                          
#-------------------------------------------------------------------------------
  "終了"              => ["終了"]}
end
#==============================================================================
# ■ Game_Actor "スロー再生",
#------------------------------------------------------------------------------
# 　アクターごとに基本アクションを指定します
#==============================================================================
class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # ● アクターIDから素手（武器なし）時のアクションを決めます
  #--------------------------------------------------------------------------
  # when 1 ←この数字がアクターID
  # return "通常攻撃" ←対応する通しアクション名を入れてください
  def non_weapon
    case @actor_id
    when 1
      return "通常攻撃"
    end
    # 上記のアクターID以外すべてに適用されるアクション
    return "通常攻撃"
  end
  #--------------------------------------------------------------------------
  # ● 通常待機
  #--------------------------------------------------------------------------
  def normal
    case @actor_id
    when 1
      return "待機"
    end
    # 上記のアクターID以外すべてに適用されるアクション
    return "待機"
  end
  #--------------------------------------------------------------------------
  # ● ピンチ（HP1/4以下）
  #--------------------------------------------------------------------------
  def pinch
    case @actor_id
    when 1
      return "ピンチ待機"
    end
    # 上記のアクターID以外すべてに適用されるアクション
    return "ピンチ待機"
  end
  #--------------------------------------------------------------------------
  # ● 防御
  #--------------------------------------------------------------------------
  def defence
    case @actor_id
    when 1
      return "防御"
    end
    # 上記のアクターID以外すべてに適用されるアクション
    return "防御"
  end
  #--------------------------------------------------------------------------
  # ● ダメージ　対象アニメ時、ヒットしていればこのアクションを取ります
  #--------------------------------------------------------------------------
  def damage_hit
    case @actor_id
    when 1
      return "ダメージ"
    end
    # 上記のアクターID以外すべてに適用されるアクション
    return "ダメージ"
  end  
  #--------------------------------------------------------------------------
  # ● 回避　対象アニメ時、ヒットしていなければこのアクションを取ります
  #--------------------------------------------------------------------------
  def evasion
    case @actor_id
    when 1
      return "回避"
    end
    # 上記のアクターID以外すべてに適用されるアクション
    return "回避"
  end  
  #--------------------------------------------------------------------------
  # ● コマンド入力前動作
  #--------------------------------------------------------------------------
  def command_b
    case @actor_id
    when 1
      return "コマンド入力"
    end
    # 上記のアクターID以外すべてに適用されるアクション
    return "コマンド入力"
  end
  #--------------------------------------------------------------------------
  # ● コマンド入力後動作
  #--------------------------------------------------------------------------
  def command_a
    case @actor_id
    when 1
      return "コマンド入力後"
    end
    # 上記のアクターID以外すべてに適用されるアクション
    return "コマンド入力後"
  end
  #--------------------------------------------------------------------------
  # ● 逃走成功
  #--------------------------------------------------------------------------
  def run_success
    case @actor_id
    when 1
      return "逃走"
    end
    # 上記のアクターID以外すべてに適用されるアクション
    return "逃走"
  end
  #--------------------------------------------------------------------------
  # ● 逃走失敗
  #--------------------------------------------------------------------------
  def run_ng
    case @actor_id
    when 1
      return "逃走失敗"
    end
    # 上記のアクターID以外すべてに適用されるアクション
    return "逃走失敗"
  end
  #--------------------------------------------------------------------------
  # ● 勝利
  #--------------------------------------------------------------------------
  def win
    case @actor_id
    when 1
      return "勝利"
    end
    # 上記のアクターID以外すべてに適用されるアクション
    return "勝利"
  end
  #--------------------------------------------------------------------------
  # ● 戦闘突入時のアクション
  #--------------------------------------------------------------------------  
  def first_action
    case @actor_id
    when 1
      return "戦闘開始"
    end
    # 上記のアクターID以外すべてに適用されるアクション
    return "戦闘開始"
  end
  #--------------------------------------------------------------------------
  # ● アクションが中断された場合の復帰アクション
  #--------------------------------------------------------------------------  
  def recover_action
    case @actor_id
    when 1
      return "座標復帰"
    end
    # 上記のアクターID以外すべてに適用されるアクション
    return "座標復帰"
  end
  #--------------------------------------------------------------------------
  # ● 影グラフィック  キャラクターフォルダから参照
  #--------------------------------------------------------------------------
  # return "shadow00" ←指定する画像ファイル名を入れてください
  def shadow
    case @actor_id
    when 1
      return "shadow00"
    end
    # 上記のアクターID以外すべてに適用される影グラフィック
    return "shadow00"
  end
  #--------------------------------------------------------------------------
  # ● 影グラフィックの位置を微調整
  #--------------------------------------------------------------------------
  # return [横座標, 縦座標]
  def shadow_plus
    case @actor_id
    when 1
      return [ 0, 4]
    end
    # 上記のアクターID以外すべてに適用される位置
    return [ 0, 4]
  end
end
#==============================================================================
# ■ Game_Enemy
#------------------------------------------------------------------------------
# 　エネミーの基本アクション指定
#==============================================================================
class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  # ● エネミーIDから武器設定なしの通常攻撃アクションを決めます
  #--------------------------------------------------------------------------
  # when 1 ←この数字がエネミーID
  # return "敵武器なし攻撃" ←対応する通しアクション名を入れてください
  def base_action
    case @enemy_id
    when 1
      return "敵武器なし攻撃"
    end
    # 上記のエネミーID以外すべてに適用されるアクション
    return "敵武器なし攻撃"
  end
  #--------------------------------------------------------------------------
  # ● 通常待機
  #--------------------------------------------------------------------------
  def normal
    case @enemy_id
    when 1
      return "待機"
    end
    # 上記のエネミーID以外すべてに適用されるアクション
    return "待機"
  end
  #--------------------------------------------------------------------------
  # ● ピンチ（HP1/4以下）
  #--------------------------------------------------------------------------
  def pinch
    case @enemy_id
    when 1
      return "待機"
    end
    # 上記のエネミーID以外すべてに適用されるアクション
    return "待機"
  end
  #--------------------------------------------------------------------------
  # ● 防御
  #--------------------------------------------------------------------------  
  def defence
    case @enemy_id
    when 1
      return "防御"
    end
    # 上記のエネミーID以外すべてに適用されるアクション
    return "防御"
  end
  #--------------------------------------------------------------------------
  # ● ダメージ　対象アニメ時、ヒットしていればこのアクションを取ります
  #--------------------------------------------------------------------------
  def damage_hit
    case @enemy_id
    when 1
      return "ダメージ"
    end
    # 上記のエネミーID以外すべてに適用されるアクション
    return "ダメージ"
  end
  #--------------------------------------------------------------------------
  # ● 回避　対象アニメ時、ヒットしてなければこのアクションを取ります
  #--------------------------------------------------------------------------
  def evasion
    case @enemy_id
    when 1
      return "エネミー回避"
    end
    # 上記のエネミーID以外すべてに適用されるアクション
    return "エネミー回避"
  end
  #--------------------------------------------------------------------------
  # ● 逃走
  #--------------------------------------------------------------------------
  def run_success
    case @enemy_id
    when 1
      return "エネミー逃走"
    end
    # 上記のエネミーID以外すべてに適用されるアクション
    return "エネミー逃走"
  end
  #--------------------------------------------------------------------------
  # ● 戦闘突入時のアクション
  #--------------------------------------------------------------------------  
  def first_action
    case @enemy_id
    when 1
      return "戦闘開始"
    end
    # 上記のエネミーID以外すべてに適用されるアクション
    return "戦闘開始"
  end
  #--------------------------------------------------------------------------
  # ● アクションが中断された場合の復帰アクション
  #--------------------------------------------------------------------------  
  def recover_action
    case @enemy_id
    when 1
      return "座標復帰"
    end
    # 上記のエネミーID以外すべてに適用されるアクション
    return "座標復帰"
  end
  #--------------------------------------------------------------------------
  # ● 影グラフィック  キャラクターフォルダから参照
  #--------------------------------------------------------------------------
  # return "shadow01" ←指定する画像ファイル名を入れてください。
  def shadow
    case @enemy_id
    when 1
      return "shadow01"
    when 30
      return ""
    end
    # 上記のエネミーID以外すべてに適用される影グラフィック
    return "shadow01"
  end
  #--------------------------------------------------------------------------
  # ● 影グラフィックの位置を微調整
  #--------------------------------------------------------------------------
  # return [横座標, 縦座標]
  def shadow_plus
    case @enemy_id
    when 1
      return [ 0, -8]
    end
    # 上記のエネミーID以外すべてに適用される位置
    return [ 0, 0]
  end
  #--------------------------------------------------------------------------
  # ● エネミー武器設定  アクションとアニメは武器のものに反映されます
  #--------------------------------------------------------------------------
  # return 1 ←この数字が武器ID。0にすると素手扱いになります。
  #            エネミーアニメをONにしていると画像も表示されます。
  def weapon
    case @enemy_id
    when 1
      return 2
    end
    # 上記のエネミーID以外すべてに適用される武器ID
    return 0
  end
  #--------------------------------------------------------------------------
  # ● 戦闘配置の微調整  データベースで設定できない広範囲の座標はここで調整
  #--------------------------------------------------------------------------
  # return [ 0, 0] => [X座標、Y座標] この数値分データベース上の配置から変化します
  def position_plus
    case @enemy_id
    when 1
      return [0, 0]
    end
    # 上記のエネミーID以外すべてに適用される座標調整
    return [ 0, 0]
  end
  #--------------------------------------------------------------------------
  # ● エネミーのコラプス(撃破時の退場)タイプ
  #--------------------------------------------------------------------------
  # コラプスさせずに残すなら1、ノーマルタイプは2、ボスタイプは3
  def collapse_type
    case @enemy_id
    when 1
      return 2
    when 30
      return 3
    end
    # 上記のエネミーID以外すべてに適用されるコラプス
    return 2
  end
  #--------------------------------------------------------------------------
  # ● エネミーアニメ
  #--------------------------------------------------------------------------
  # エネミーにアニメさせるか　trueにするとアクターと同等の扱いになります。
  # [設定方法]
  # 1.エネミーのアニメ画像をキャラクターフォルダに用意
  # 2.データベースのエネミーバトラーファイル名を、参照するキャラファイル名にする
  def anime_on
    case @enemy_id
    when 1
      return false
    end
    # 上記のエネミーID以外すべてに適用されるアニメ設定
    return false
  end
  #--------------------------------------------------------------------------
  # ● エネミーアニメ時の自動反転
  #--------------------------------------------------------------------------
  # 上のアニメがONになっているエネミーの画像や武器アニメを自動反転させるならtrue
  def action_mirror
    case @enemy_id
    when 1
      return false
    end
    # 上記のエネミーID以外すべてに適用されるアニメ設定
    return false
  end
end
module RPG
#==============================================================================
# ■ module RPG
#------------------------------------------------------------------------------
# 　ステートアクション設定です。
#==============================================================================
class State
#--------------------------------------------------------------------------
# ● ID指定　ステートによって通常待機、ピンチのアクションが変わります。
#--------------------------------------------------------------------------
# when 1 ←この数字がステートID
# return "気絶" ←対応する通しアクション名を入れてください
  def base_action
    case @id
    when 1  # 戦闘不能（HP0）時です。最優先で選択されます
      return "気絶"
    when 2,3,4,5,7  
      return "状態異常待機"
    when 6  
      return "睡眠待機"
    when 17  
      return "浮遊待機"
    end
    # 上記IDのステート以外すべてに適用される通しアクション
    return "待機"
  end
#--------------------------------------------------------------------------
# ● 拡張設定　ステートIDから拡張設定を決めます。重複可能。
#--------------------------------------------------------------------------
# "0ターン解除"…行動順にかかわらずそのターンでステートを解除
# "エネミー除外"…エネミーに取らせたくないステートアクション
# "POPなし"…ステート付加時、ダメージウインドウにステート名を表示しない
# "アイコン非表示"…ステータスウインドウにステートアイコンを表示しない
# "ステートアクション禁止"…ステートが付加しても待機アクションに反映させない
# "スリップダメージ"…下のスリップダメージ設定を適用させます
# "なし"…拡張なし
  def extension
    case @id
    when 1  # 戦闘不能
      return ["POPなし","エネミー除外"]
    when 2  # 毒
      return ["スリップダメージ"]
    when 18  
      return ["0ターン解除","アイコン非表示"]
    when 19  
      return ["0ターン解除","アイコン非表示"]
    when 20  
      return ["アイコン非表示","ステートアクション禁止"]
    end
    # 上記のID以外すべてに適用される拡張設定
    return ["なし"]
  end
#--------------------------------------------------------------------------
# ● スリップダメージ拡張設定　スリップ回復も含まれます
#--------------------------------------------------------------------------
# when 1 ←この数字がステートID。上で"スリップダメージ"が付いている時のみ有効
# 　　　　 複数の設定も反映可。例)[["hp",0,5,true],["mp",0,5,true]]
#                          
#  　      対象  定数  割合  POP  戦闘不能許可
# return [["hp",    0,  10, true,  true]]
#
# 対象…スリップダメージ対象が HPなら"hp" MPなら"mp"
# 定数…この数値がそのままダメージ。マイナスなら回復。数値は多少分散します
# 割合…対象の最大値の割合でダメージ。数値は％。定数と足し算され多少分散します
# POP…戦闘画面で数値をPOPさせるならtrue
# 戦闘不能許可…HP0を許可するならtrue
  def slip_extension
    case @id
    when 2  # 毒
      return [["hp", 0, 10, true, true]]
    end
    return []
  end
end
#==============================================================================
# ■ module RPG
#------------------------------------------------------------------------------
# 　武器アクション設定です。
#==============================================================================
class Weapon
#--------------------------------------------------------------------------
# ● アクション指定　装備している武器のIDから通常攻撃のアクションを決めます。
#--------------------------------------------------------------------------
# when 1 ←この数字が武器ID
# return "通常攻撃" ←対応する通しアクション名を入れてください
  def base_action
    case @id
    when 1
      return "通常攻撃"
    end
    # 上記のID以外すべてに適用されるアクション
    return "通常攻撃"
  end
#--------------------------------------------------------------------------
# ● グラフィック指定　装備している武器のIDから武器グラフィックを指定します
#--------------------------------------------------------------------------
# return "001-Weapon01" ←対応する武器グラフィックのファイル名を入れてください
#                         武器グラフィックはキャラクターフォルダに入れてください
# アイコンを利用する場合、IDにないものは全てアイコン画像を利用します
# 特定の武器を非表示にしたい場合は空の画像を用意して、それを指定します
  def graphic
    case @id
    when 1
      return ""
    end
    # 上記ID以外は全てアイコン画像を利用
    return ""
  end
#--------------------------------------------------------------------------
# ● 飛ばしアニメに貼り付ける武器グラフィック　アイコンフォルダを参照します
#--------------------------------------------------------------------------
# アニメ飛ばし用の武器画像は上の設定とは別に指定。弓と矢の表現などに。
# ここで設定しなかった武器は上の画像と同じになります。
  def flying_graphic
    case @id
    when 1
      return ""
    end
    # 上記ID以外は全て上の画像を利用
    return ""
  end
end  
#==============================================================================
# ■ module RPG
#------------------------------------------------------------------------------
# 　スキルアクション設定です。
#==============================================================================
class Skill
#--------------------------------------------------------------------------
# ● スキルIDからアクションを決めます。
#--------------------------------------------------------------------------  
  def base_action
    case @id
    when 84
      return "武器投げ"
    when 85
      return "多段攻撃"
    when 86
      return "高速多段攻撃"  
    when 87
      return "個別全体遠距離攻撃"  
    when 88
      return "全体遠距離攻撃"
    when 89
      return "多段攻撃ランダム用"  
    when 90
      return "ヒールに派生"  
    when 91
      return "適当に派生"  
    when 92
      return "通常攻撃"  
    when 93
      return "カットイン"  
    when 94
      return "踏み潰し"
    when 95
      return "全体攻撃1"
    when 96
      return "汎用スキル個別処理"
    when 97
      return "ネコに変身"
    when 98
      return "二人同時攻撃"
    when 99
      return "二人同時攻撃準備"
    when 100
      return "四人同時攻撃"
    when 101
      return "四人同時攻撃準備"
    when 102
      return "四人同時攻撃準備"
    when 103
      return "四人同時攻撃準備"
    when 104
      return "味方投げつけ"
    end
    # 上記のID以外すべてに適用されるアクション  
    return "汎用スキル使用"
  end
#--------------------------------------------------------------------------
# ● 拡張設定　スキルIDから拡張設定を決めます。重複可能。
#--------------------------------------------------------------------------
# "ヘルプ非表示"…アクション時、ヘルプウインドウにスキル名を表示しない
# "全域"…ターゲット範囲が敵味方全体に
# "ランダムターゲット"…ターゲット内から一体をランダムで選ぶように
# "自分以外"…ターゲット内から自分を除く
# "ダメージアクション禁止"…ダメージを与えた際のアクションを取らせない
# "行動前フラッシュなし"…行動時にバトラーを光らせない
# "なし"…拡張なし
  def extension
    case @id
    when 86
      return ["ダメージアクション禁止"]
    when 89
      return ["ランダムターゲット"]
    when 94
      return ["ダメージアクション禁止"]
    when 96
      return ["全域"]
    when 98
      return ["ダメージアクション禁止"]
    when 99
      return ["ヘルプ非表示","行動前フラッシュなし"]
    when 100
      return ["ダメージアクション禁止"]
    when 101
      return ["ヘルプ非表示","行動前フラッシュなし"]
    when 102
      return ["ヘルプ非表示","行動前フラッシュなし"]
    when 103
      return ["ヘルプ非表示","行動前フラッシュなし"]
    end
    # 上記のID以外すべてに適用される拡張設定
    return ["なし"]
  end
end  
#==============================================================================
# ■ module RPG
#------------------------------------------------------------------------------
# 　アイテムアクション設定です。
#==============================================================================
class Item
#--------------------------------------------------------------------------
# ● アイテムIDからアクションを決めます。
#--------------------------------------------------------------------------  
  def base_action
    case @id
    when 1
      return "アイテム使用"
    end
    # 上記のID以外すべてに適用されるアクション
    return "アイテム使用"
  end
#--------------------------------------------------------------------------
# ● 拡張設定　アイテムIDから拡張設定を決めます。重複可能。
#--------------------------------------------------------------------------
# "ヘルプ非表示"…ヘルプウインドウにアイテム名を表示しない
# "全域"…ターゲット範囲が敵味方全体に
# "ランダムターゲット"…ターゲット内から一体をランダムで選ぶように
# "自分以外"…ターゲット内から自分を除く
# "ダメージアクション禁止"…ダメージを与えた際のアクションを取らせない
# "行動前フラッシュなし"…行動時にバトラーを光らせない
# "なし"…拡張なし
  def extension
    case @id
    when 1
      return ["なし"]
    end
    # 上記のID以外すべてに適用される拡張設定
    return ["なし"]
  end
end
end

Then:

[Show/Hide] Code2

CODE

#==============================================================================
# ■ Sprite_Battler ver1.2
#------------------------------------------------------------------------------
# 　バトラー表示用のスプライトです。
#==============================================================================
class Sprite_Battler < Sprite_Base
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(viewport, battler = nil)
    super(viewport)
    @battler = battler
    @battler_visible = false
    @effect_type = 0                   # エフェクトの種類
    @effect_duration = 0               # エフェクトの残り時間
    @move_x = 0                        # 変化したX座標の累計
    @move_y = 0                        # 変化したY座標の累計
    @move_z = 0                        # 変化したZ座標の累計
    @distanse_x = 0                    # X座標の移動距離
    @distanse_y = 0                    # Y座標の移動距離
    @moving_x = 0                      #１フレームあたりのX座標移動距離
    @moving_y = 0                      #１フレームあたりのY座標移動距離
    @move_speed_x = 0                  # X座標の移動速度
    @move_speed_y = 0                  # Y座標の移動速度
    @move_speed_plus_x = 0             # X座標の加減速時の補足移動速度
    @move_speed_plus_y = 0             # Y座標の加減速時の補足移動速度
    @move_boost_x = 0                  # X座標加速度
    @move_boost_y = 0                  # Y座標加速度
    @jump_time = 0                     # ジャンプ時間
    @jump_time_plus = 0                # ジャンプ時間補足
    @jump_up = 0                       # ジャンプ上昇
    @jump_down = 0                     # ジャンプ下降
    @jump_size = 0                     # ジャンプ高度
    @float_time = 0                    # 浮遊時間
    @float_up = 0                      # １フレームあたりの浮遊高度
    @jump_plus = 0                     # ジャンプに対する影位置補正
    @angle = 0                         # 回転角度
    @angling = 0                       # １フレームあたりの回転角度
    @angle_time = 0                    # 回転時間
    @angle_reset = 0                   # 角度をリセットするか
    @zoom_x = 0                        # 横の拡大率
    @zoom_y = 0                        # 縦の拡大率
    @zooming_x = 0                     # １フレームあたりの横拡大率
    @zooming_y = 0                     # １フレームあたりの縦拡大率
    @zoom_time = 0                     # 拡大時間
    @zoom_reset = 0                    # 拡大をリセットするか
    @target_battler = []               # ターゲットバトラー情報
    @now_targets = []                  # ターゲットバトラー記憶
    @pattern = 0                       # セル横位置（更新位置）
    @pattern_back = false              # リピートフラグ
    @wait = 0                          # 次の動作待ち時間
    @unloop_wait = 0                   # 非ループ系アニメ終了時の待ち時間
    @action = []                       # 行動
    @anime_kind = 0                    # セル縦位置（アニメ種類位置）
    @anime_speed = 0                   # セル更新速度
    @frame = 0                         # 消費されるセル更新時間
    @anime_loop = 0                    # ループ方式
    @anime_end = false                 # バトラーのアニメが終わったか
    @anime_freeze = false              # 固定アニメか
    @anime_freeze_kind = false         # 固定するパターン位置
    @anime_moving = false              # 飛ばしアニメ中か
    @base_width = N01::ANIME_PATTERN   # セルの横分割数
    @base_height = N01::ANIME_KIND     # セルの縦分割数
    @width = 0                         # 横矩形
    @height = 0                        # 縦矩形
    @picture_time = 0                  # ピクチャー表示時間
    @individual_targets = []           # 個別処理の保持ターゲット
    @balloon_duration = 65             # ふきだしアニメ時間
    # バトラーがいない場合は処理を中断
    return @battler_visible = false if @battler == nil
    # バトラーがアクターの場合、またはエネミーアニメがオンの場合
    @anime_flug = true if @battler.actor?
    @anime_flug = true if !@battler.actor? && @battler.anime_on
    # バトラー作成
    make_battler
  end
  #--------------------------------------------------------------------------
  # ● バトラー作成
  #--------------------------------------------------------------------------
  def make_battler
    # 初期配置の取得
    @battler.base_position
    # 色相はバトラーとして認識
    @battler_hue = @battler.battler_hue
    # バトラーがアクターの場合、またはエネミーアニメがオンの場合
    if @anime_flug
      # メイン武器を用意
      @weapon_R = Sprite_Weapon.new(viewport,@battler)
      # 味方はキャラクター名、エネミーはバトラー名を取得
      @battler_name = @battler.character_name if @battler.actor?
      @battler_name = @battler.battler_name unless @battler.actor?
      # エネミー反転がオンの場合、画像を反転させる
      self.mirror = true if !@battler.actor? && @battler.action_mirror
      # 歩行グラフィックを利用するかどうかで転送元の矩形サイズの認識先を変える
      self.bitmap = Cache.character(@battler_name) if N01::WALK_ANIME
      self.bitmap = Cache.character(@battler_name + "_1") unless N01::WALK_ANIME
      # 転送元の矩形を取得
      @width = self.bitmap.width / @base_width
      @height = self.bitmap.height / @base_height
      # 矩形を設定
      @sx = @pattern * @width
      @sy = @anime_kind * @height
      # バトラー本体を描画
      self.src_rect.set(@sx, @sy, @width, @height)
    # アニメしないバトラーの場合
    else
      # ビットマップを取得、設定
      @battler_name = @battler.battler_name
      self.bitmap = Cache.battler(@battler_name, @battler_hue)
      @width = bitmap.width
      @height = bitmap.height
    end
    # バックアタック時には画像を反転させる
    self.mirror = false if self.mirror && $back_attack && N01::BACK_ATTACK
    self.mirror = true if $back_attack && !self.mirror && N01::BACK_ATTACK
    # 位置を初期化
    @battler.reset_coordinate
    # 原点を決定
    self.ox = @width / 2
    self.oy = @height * 2 / 3
    # スプライトの座標を設定
    update_move
    # アニメ飛ばし用スプライトを用意
    @move_anime = Sprite_MoveAnime.new(viewport,battler)
    # ピクチャ用スプライトを用意
    @picture = Sprite.new
    # 影スプライトを用意
    make_shadow if N01::SHADOW
    # ダメージスプライト作成
    @damage = Sprite_Damage.new(viewport,battler)
  end
  #--------------------------------------------------------------------------
  # ● 影作成
  #--------------------------------------------------------------------------
  def make_shadow
    @shadow.dispose if @shadow != nil
    @battler_hue = @battler.battler_hue
    @shadow = Sprite.new(viewport)
    @shadow.z = 200
    @shadow.visible = false
    # バトラーに当てられた影グラフィックを用意
    @shadow.bitmap = Cache.character(@battler.shadow)
    @shadow_height = @shadow.bitmap.height
    # 影位置の微調整用インスタンス
    @shadow_plus_x = @battler.shadow_plus[0] - @width / 2
    @shadow_plus_y = @battler.shadow_plus[1]
    # バトラー画像のサイズに合わせて影画像をリサイズ
    @shadow.zoom_x = @width * 1.0 / @shadow.bitmap.width
    # 更新
    update_shadow
    # フェードに影が引っかからないようにフラグを立てる
    @skip_shadow = true
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  def dispose
    self.bitmap.dispose if self.bitmap != nil
    @weapon_R.dispose if @weapon_R != nil
    @move_anime.dispose if @move_anime != nil
    @picture.dispose if @picture != nil
    @shadow.dispose if @shadow != nil
    @damage.dispose if @damage != nil
    @balloon.dispose if @balloon != nil
    mirage_off
    super
  end  
  #--------------------------------------------------------------------------
  # ● ダメージアクション  action = [アニメID,反転フラグ,リアクション許可]
  #--------------------------------------------------------------------------
  def damage_action(action)
    damage = @battler.hp_damage
    damage = @battler.mp_damage if @battler.mp_damage != 0
    # ヒットしている時のみアニメ実行
    unless @battler.evaded or @battler.missed or action[0] == nil
      @battler.animation_id = action[0]
      @battler.animation_mirror = action[1]
    end
    # ダメージアクション実行
    start_action(@battler.damage_hit) if damage > 0 && action[2]
    # 攻撃が当たっていない場合は回避アクション実行
    if @battler.evaded or @battler.missed
      start_action(@battler.evasion) if action[2]
      Sound.play_evasion
    end
    @damage.damage_pop
  end
  #--------------------------------------------------------------------------
  # ● ダメージ数値POP
  #--------------------------------------------------------------------------
  def damage_pop(damage)
    @damage.damage_pop(damage)
  end  
  #--------------------------------------------------------------------------
  # ● 戦闘開始行動
  #--------------------------------------------------------------------------
  def first_action
    # 行動できるかチェックし、できなければそのステートのアクション開始
    action = @battler.first_action unless @battler.restriction == 4
    action = $data_states[@battler.state_id].base_action if @battler.states[0] != nil && @battler.restriction == 4
    start_action(action)
    @skip_shadow = false
  end
  #--------------------------------------------------------------------------
  # ● アクション開始
  #--------------------------------------------------------------------------
  def start_action(kind)
    # 各種動作を初期化
    reset
    # 現在取っている待機アクションを記憶
    stand_by
    # 新しいアクション内容の決定
    @action = N01::ACTION[kind].dup
    # 行動配列の先頭からシフト
    active = @action.shift
    # 自動で終了を付ける
    @action.push("終了")
    # 現在のアクションを決定
    @active_action = N01::ANIME[active]
    # ウエイト設定
    @wait = active.to_i if @active_action == nil
    # 単発アクション開始
    action
  end
  #--------------------------------------------------------------------------
  # ● 強制単発アクション開始
  #--------------------------------------------------------------------------
  def start_one_action(kind,back)
    # 各種動作を初期化
    reset
    # 現在取っている待機アクションを記憶
    stand_by
    # 座標リセットアクションをセッティング
    @action = [back]
    # 自動で終了を付ける
    @action.push("終了")
    # 現在のアクションを決定
    @active_action = N01::ANIME[kind]
    # 単発アクション開始
    action
  end
  #--------------------------------------------------------------------------
  # ● 次のアクションへ
  #--------------------------------------------------------------------------
  def next_action
    # ウェイト中の場合キャンセル
    return @wait -= 1 if @wait > 0
    # まだ全アニメセルが終了していない場合キャンセル
    return if @anime_end == false
    # 最後のアニメセル表示待ち
    return @unloop_wait -= 1 if @unloop_wait > 0
    # 行動配列の先頭からシフト
    active = @action.shift
    # 現在のアクションを決定
    @active_action = N01::ANIME[active]
    # ウエイト設定
    @wait = active.to_i if @active_action == nil
    # 単発アクション開始
    action
  end
  #--------------------------------------------------------------------------
  # ● 待機アクション
  #--------------------------------------------------------------------------
  def stand_by
    # 通常待機に
    @repeat_action = @battler.normal
    # HPが1/4でピンチモーションに
    @repeat_action = @battler.pinch if @battler.hp <= @battler.maxhp / 4
    # 防御中
    @repeat_action = @battler.defence if @battler.guarding?
    # 何もステートがなければ終了
    return if @battler.state_id == nil
    for state in @battler.states.reverse
      # アクション禁止のステートだったらスキップ
      next if $data_states[state.id].extension.include?("ステートアクション禁止")
      # エネミーで禁止されているステートアクションだったらスキップ
      next if @battler.is_a?(Game_Enemy) && $data_states[state.id].extension.include?("エネミー除外")
      # ステートのモーションに
      @repeat_action = $data_states[state.id].base_action
    end
  end
  #--------------------------------------------------------------------------
  # ● 各種変化を初期化
  #--------------------------------------------------------------------------
  def reset
    self.zoom_x = self.zoom_y = 1
    self.oy = @height * 2 / 3
    @angle = self.angle = 0
    @anime_end = true
    @non_repeat = false
    @anime_freeze = false
    @unloop_wait = 0
  end  
  #--------------------------------------------------------------------------
  # ● ジャンプを初期化
  #--------------------------------------------------------------------------
  def jump_reset
    @battler.jump = @jump_time = @jump_time_plus = @jump_up = @jump_down = 0
    @jump_size = @jump_plus = @float_time = @float_up = 0
  end
  #--------------------------------------------------------------------------
  # ● ターゲット情報を受け取る
  #--------------------------------------------------------------------------
  def get_target(target)
    # 個別処理中は中止(全域で自分が巻き込まれた時ターゲット情報が狂わないように)
    return if @battler.individual
    @target_battler = target
  end
  #--------------------------------------------------------------------------
  # ● アクション情報をバトラーに格納
  #--------------------------------------------------------------------------
  def send_action(action)
    @battler.play = 0
    @battler.play = action if @battler.active
  end
  #--------------------------------------------------------------------------
  # ● バトラー追加
  #--------------------------------------------------------------------------
  def battler_join
    if @battler.exist? && !@battler_visible
      # 戦闘不能からの復活なら処理をスキップ
      return @battler.revival = false if @battler.revival
      @anime_flug = true if @battler.actor?
      @anime_flug = true if !@battler.actor? && @battler.anime_on
      make_battler
      @damage = Sprite_Damage.new(viewport,battler)
      @join = true
      first_action
    end
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新　※再定義
  #--------------------------------------------------------------------------
  def update
    super
    # バトラーがいない場合スキップ
    return self.bitmap = nil if @battler == nil
    # バトラー追加
    battler_join
    # 次のアクションへ
    next_action
    # アニメパターン更新
    update_anime_pattern
    # ターゲット更新
    update_target
    # 強制アクション更新
    update_force_action
    # 座標更新
    update_move
    # 影更新
    update_shadow if @shadow != nil
    # 武器更新
    @weapon_R.update if @weapon_action
    # 浮遊更新
    update_float if @float_time > 0
    # 回転更新
    update_angle if @angle_time > 0
    # 拡大縮小更新
    update_zoom if @zoom_time > 0
    # 残像更新
    update_mirage if @mirage_flug
    # ピクチャ更新
    update_picture if @picture_time > 0
    # アニメ飛ばし更新
    update_move_anime if @anime_moving
    # ふきだしアニメ更新
    update_balloon if @balloon_duration <= 64
    # ダメージスプライト更新
    @damage.update
    setup_new_effect
    update_effect
  end
  #--------------------------------------------------------------------------
  # ● アニメパターン更新
  #--------------------------------------------------------------------------
  def update_anime_pattern
    # 更新時間がくるまでスキップ
    return @frame -= 1 if @frame != 0
    # 必要な時だけ武器アニメ更新
    @weapon_R.action if @weapon_action && @weapon_R != nil
    # アニメのコマが最後まで到達したらリピート方法をチェック
    if @pattern_back
      # 往復ループ
      if @anime_loop == 0
        @pattern -= 1
        @pattern_back = false if @pattern == 0
        @anime_end = true if @pattern == 0
      # 片道ループもしくはループしない
      else
        @anime_end = true
        @pattern = 0 if @anime_loop == 1
        @pattern_back = false if @anime_loop == 1
      end  
    # アニメのコマを進める    
    else
      @pattern += 1
      @pattern_back = true if @pattern == @base_width - 1
    end
    # 更新時間を初期化
    @frame = @anime_speed
    # アニメ固定の場合は横矩形を固定
    return  if @anime_freeze
    # 転送元の矩形を設定
    return unless @anime_flug
    @sx = @pattern * @width
    @sy = @anime_kind * @height
    self.src_rect.set(@sx, @sy, @width, @height)
  end
  #--------------------------------------------------------------------------
  # ● ターゲット更新 action = ["N01target_change",ターゲット情報]
  #--------------------------------------------------------------------------
  def update_target
    # ターゲットチェック
    return if @battler.force_target == 0
    # 個別処理中は中止(全域で自分が巻き込まれた時ターゲット情報が狂わないように)
    return if @battler.individual
    @target_battler = @battler.force_target[1]
    @battler.force_target = 0
  end  
  #--------------------------------------------------------------------------
  # ● 強制アクション更新 action = [識別,復帰,実行するアクション]
  #--------------------------------------------------------------------------
  def update_force_action
    # 強制アクションチェック
    action = @battler.force_action
    return if action == 0
    @battler.force_action = 0
    # アクティブ中は割り込ませない
    return if @battler.active
    # コラプスならそのまま行動に直結
    return collapse_action if action[0] == "N01collapse"
    # 単発ならそのまま行動に直結
    return start_one_action(action[2],action[1]) if action[0] == "単発"
    # 通しはアクションとして扱う
    start_action(action[2])
    # 座標復帰の有無
    return if action[1] == ""
    # 終了位置を入れ替えて復帰アクションを入れる
    @action.delete("終了")
    @action.push(action[1])
    @action.push("終了")
  end  
  #--------------------------------------------------------------------------
  # ● 座標更新
  #--------------------------------------------------------------------------
  def update_move
    # 加減速で出る距離の増減を補完
    if @move_speed_plus_x > 0
      # 移動計算
      @move_x += @moving_x
      # 移動を実行
      @battler.move_x = @move_x
      @move_speed_plus_x -= 1
    elsif @move_speed_x > 0
      # 加速の場合
      if @move_boost_x != 0
        @moving_x += @move_boost_x
      end  
      # 移動計算
      @move_x += @moving_x
      # 移動を実行
      @battler.move_x = @move_x
      @move_speed_x -= 1
    end
    # 加減速で出る距離の増減を補完
    if @move_speed_plus_y > 0
      # 移動計算
      @move_y += @moving_y
      # 移動を実行
      @battler.move_y = @move_y
      @move_speed_plus_y -= 1
    elsif @move_speed_y > 0
      # 加速の場合
      if @move_boost_y != 0
        @moving_y += @move_boost_y
      end  
      # 移動計算
      @move_y += @moving_y
      # 移動を実行
      @battler.move_y = @move_y
      @move_speed_y -= 1
    end
    # ジャンプ上昇
    if @jump_up != 0
      # 移動計算
      @jump_plus += @jump_up
      # 移動を実行
      @battler.jump = @jump_plus
      @jump_up = @jump_up / 2
      @jump_time -= 1
      # ジャンプが頂点に達したら
      if @jump_time == 0 or @jump_up == @jump_sign
        @jump_down = @jump_up * 2 * @jump_sign * @jump_sign2
        @jump_time_plus += @jump_time * 2
        @jump_up = 0
        return
      end  
    end  
    # ジャンプ下降
    if @jump_down != 0
      if @jump_time_plus != 0
        @jump_time_plus -= 1
      elsif @jump_down != @jump_size
        # 移動計算
        @jump_plus += @jump_down
        # 移動を実行
        @battler.jump = @jump_plus
        @jump_down = @jump_down * 2
        if @jump_down == @jump_size
          if @jump_flug
            @jump_flug = false
          else
            # 移動計算
            @jump_plus += @jump_down
            # 移動を実行
            @battler.jump = @jump_plus
            @jump_down = @jump_size = 0
          end
        end  
      end
    end
    # スプライトの座標を設定
    self.x = @battler.position_x
    self.y = @battler.position_y
    self.z = @battler.position_z
  end
  #--------------------------------------------------------------------------
  # ● 影更新
  #--------------------------------------------------------------------------
  def update_shadow
    @shadow.opacity = self.opacity
    @shadow.x = self.x + @shadow_plus_x
    @shadow.y = self.y + @shadow_plus_y - @jump_plus
  end
  #--------------------------------------------------------------------------
  # ● 浮遊更新
  #--------------------------------------------------------------------------
  def update_float
    @float_time -= 1
    @jump_plus += @float_up
    @battler.jump = @jump_plus
  end  
  #--------------------------------------------------------------------------
  # ● 回転更新
  #--------------------------------------------------------------------------
  def update_angle
    # 回転実行
    @angle += @angling
    self.angle = @angle
    @angle_time -= 1
    # 回転時間がなくなったら項目をリセット
    return @angle = 0 if @angle_time == 0
    # 復帰フラグがあれば角度を0に戻す
    self.angle = 0 if @angle_reset
  end  
  #--------------------------------------------------------------------------
  # ● 拡大縮小更新
  #--------------------------------------------------------------------------
  def update_zoom
    # 拡大縮小実行
    @zoom_x += @zooming_x
    @zoom_y += @zooming_y
    self.zoom_x = @zoom_x
    self.zoom_y = @zoom_y
    @zoom_time -= 1
    # 拡大縮小時間がなくなったら項目をリセット
    return if @zoom_time != 0
    @zoom_x = @zoom_y = 0
    self.oy = @height * 2 / 3
    # 復帰フラグがあれば戻す
    self.zoom_x = self.zoom_y = 1 if @zoom_reset
  end  
  #--------------------------------------------------------------------------
  # ● 残像更新
  #--------------------------------------------------------------------------
  def update_mirage
    # 残像は最大3つまで表示し、２フレームごとに更新
    mirage(@mirage0) if @mirage_count == 1
    mirage(@mirage1) if @mirage_count == 3
    mirage(@mirage2) if @mirage_count == 5
    @mirage_count += 1
    @mirage_count = 0 if @mirage_count == 6
  end
  #--------------------------------------------------------------------------
  # ● ピクチャ更新
  #--------------------------------------------------------------------------
  def update_picture
    @picture_time -= 1
    @picture.x += @moving_pic_x
    @picture.y += @moving_pic_y
  end  
  #--------------------------------------------------------------------------
  # ● アニメ飛ばし更新
  #--------------------------------------------------------------------------
  def update_move_anime
    @move_anime.update
    @anime_moving = false if @move_anime.finish?
    @move_anime.action_reset if @move_anime.finish?
  end  
  #--------------------------------------------------------------------------
  # ● 崩壊エフェクトの更新　※再定義
  #--------------------------------------------------------------------------
  def update_collapse
    normal_collapse if @collapse_type == 2
    boss_collapse1 if @collapse_type == 3
  end
  #--------------------------------------------------------------------------
  # ● ふきだしアニメ更新
  #--------------------------------------------------------------------------
  def update_balloon
    @balloon_duration -= 1 if @balloon_duration > 0 && !@balloon_back
    @balloon_duration += 1 if @balloon_back
    if @balloon_duration == 64
      @balloon_back = false
      @balloon.visible = false
    elsif @balloon_duration == 0
      @balloon.visible = false if @balloon_loop == 0
      @balloon_back = true if @balloon_loop == 1
    end    
    @balloon.x = self.x - @width / 5
    @balloon.y = self.y - @balloon_height
    @balloon.z = 10
    @balloon.opacity = self.opacity
    sx = 7 * 32 if @balloon_duration < 12
    sx = (7 - (@balloon_duration - 12) / 8) * 32 unless @balloon_duration < 12
    @balloon.src_rect.set(sx, @balloon_id * 32, 32, 32)
  end
  #--------------------------------------------------------------------------
  # ● アクション実行
  #--------------------------------------------------------------------------
  def action
    return if @active_action == nil
    action = @active_action[0]
    # 反転の場合
    return mirroring if action == "反転"
    # 回転の場合  
    return angling if action == "angle"
    # 拡大縮小の場合  
    return zooming if action == "zoom"
    # 残像ONの場合
    return mirage_on if action == "残像ON"
    # 残像OFFの場合
    return mirage_off if action == "残像OFF"
    # ピクチャ表示の場合
    return picture if action == "pic"
    # ピクチャ消去の場合
    return @picture.visible = false && @picture_time = 0 if action == "ピクチャ消去"
    # グラフィックファイル変更の場合  
    return graphics_change if action == "change"
    # 戦闘アニメ表示の場合  
    return battle_anime if action == "anime"
    # ふきだしアニメ表示の場合  
    return balloon_anime if action == "balloon"
    # BGM/BGS/SE演奏の場合  
    return sound if action == "sound"
    # ゲームスイッチ操作の場合  
    return $game_switches[@active_action[1]] = @active_action[2] if action == "switch"
    # ゲーム変数操作の場合  
    return variable if action == "variable"
    # 二刀限定の場合
    return two_swords if action == "二刀限定"
    # 非二刀限定の場合
    return non_two_swords if action == "非二刀限定"
    # アクション条件の場合
    return necessary if action == "nece"
    # スキル派生の場合  
    return derivating if action == "der"
    # 個別処理開始の場合
    return individual_action if action == "個別処理開始"
    # 個別処理終了の場合
    return individual_action_end if action == "個別処理終了"
    # 待機に移行しない場合
    return non_repeat if action == "待機に移行しない"
    # 初期位置変更の場合
    return @battler.change_base_position(self.x, self.y) if action == "初期位置変更"
    # 初期位置変更解除の場合
    return @battler.base_position if action == "初期位置変更解除"
    # ターゲット変更の場合  
    return change_target if action == "target"
    # ターゲットのコラプス許可
    return send_action(action) if action == "コラプス許可"
    # アクティブ解除
    return send_action(action) if action == "アクティブ解除"
    # ステート付与の場合  
    return state_on if action == "sta+"
    # ステート解除の場合  
    return state_off if action == "sta-"
    # ゲーム全体のスピード変更の場合
    return Graphics.frame_rate = @active_action[1] if action == "fps"
    # 浮遊の場合  
    return floating if action == "float"
    # 強制アクションの場合  
    return force_action if @active_action.size == 4
    # 座標リセットの場合  
    return reseting if @active_action.size == 5
    # 移動の場合
    return moving if @active_action.size == 7
    # バトラーアニメの場合
    return battler_anime if @active_action.size == 9
    # アニメ飛ばしの場合
    return moving_anime if @active_action.size == 11
    # 終了の場合
    return anime_finish if action == "終了"
  end
  #--------------------------------------------------------------------------
  # ● 反転実行
  #--------------------------------------------------------------------------
  def mirroring  
    # すでに反転されていれば元に戻す
    if self.mirror
      self.mirror = false
      # 武器アニメも反映
      @weapon_R.mirroring if @anime_flug
    else
      self.mirror = true
      # 武器アニメも反映
      @weapon_R.mirroring if @anime_flug
    end
  end  
  #--------------------------------------------------------------------------
  # ● 回転実行
  #--------------------------------------------------------------------------
  def angling  
    # ジャンプを初期化
    jump_reset
    # 情報確認
    @angle_time = @active_action[1]
    start_angle = @active_action[2]
    end_angle = @active_action[3]
    @angle_reset = @active_action[4]
    # バックアタック時には逆に
    start_angle *= -1 if $back_attack
    end_angle *= -1 if $back_attack
    # エネミーは逆に
    start_angle *= -1 if @battler.is_a?(Game_Enemy)
    end_angle *= -1 if @battler.is_a?(Game_Enemy)
    # 時間が0以下なら即座に最終角度へ
    if @angle_time <= 0
      self.angle = end_angle
      return  @angle_time = 0
    end  
    # 回転時間から1フレームあたりの角度を出す
    @angling = (end_angle - start_angle) / @angle_time
    # 割り切れない余りを初期角度に
    @angle = (end_angle - start_angle) % @angle_time + start_angle
  end
  #--------------------------------------------------------------------------
  # ● 拡大縮小実行
  #--------------------------------------------------------------------------
  def zooming  
    # ジャンプを初期化
    jump_reset
    # 情報確認
    @zoom_time = @active_action[1]
    zoom_x = @active_action[2] - 1
    zoom_y = @active_action[3] - 1
    @zoom_reset = @active_action[4]
    @zoom_x = @zoom_y = 1
    # 時間が0以下ならスキップ
    return @zoom_time = 0 if @zoom_time <= 0
    # 拡大時間から1フレームあたりの拡大率を出す
    @zooming_x = zoom_x / @zoom_time
    @zooming_y = zoom_y / @zoom_time
  end  
  #--------------------------------------------------------------------------
  # ● 残像開始
  #--------------------------------------------------------------------------
  def mirage_on
    # 戦闘不能時には残像させない
    return if @battler.dead?
    @mirage0 = Sprite.new(self.viewport)
    @mirage1 = Sprite.new(self.viewport)
    @mirage2 = Sprite.new(self.viewport)
    @mirage_flug = true
    @mirage_count = 0
  end  
  #--------------------------------------------------------------------------
  # ● 残像表示
  #--------------------------------------------------------------------------
  def mirage(body)
    body.bitmap = self.bitmap.dup
    body.x = self.x
    body.y = self.y
    body.ox = self.ox
    body.oy = self.oy
    body.z = self.z
    body.mirror = self.mirror
    body.angle = @angle
    body.opacity = 160
    body.zoom_x = self.zoom_x
    body.zoom_y = self.zoom_y  
    body.src_rect.set(@sx, @sy, @width, @height) if @anime_flug
    body.src_rect.set(0, 0, @width, @height) unless @anime_flug
  end  
  #--------------------------------------------------------------------------
  # ● 残像終了
  #--------------------------------------------------------------------------
  def mirage_off
    @mirage_flug = false
    @mirage0.dispose if @mirage0 != nil
    @mirage1.dispose if @mirage1 != nil
    @mirage2.dispose if @mirage2 != nil
  end  
  #--------------------------------------------------------------------------
  # ● ピクチャ表示
  #--------------------------------------------------------------------------
  def picture
    # 移動開始位置を確認
    pic_x = @active_action[1]
    pic_y = @active_action[2]
    # 移動終了位置を確認
    pic_end_x = @active_action[3]
    pic_end_y = @active_action[4]
    @picture_time = @active_action[5]
    # 時間で割り、1フレーム当たりの移動速度を計算
    @moving_pic_x = (pic_end_x - pic_x)/ @picture_time
    @moving_pic_y = (pic_end_y - pic_y)/ @picture_time
    # 割り切れない場合最初に加算
    plus_x = (pic_end_x - pic_x)% @picture_time
    plus_y = (pic_end_y - pic_y)% @picture_time
    # ピクチャ表示
    @picture.bitmap = Cache.picture(@active_action[7])
    @picture.x = pic_x + plus_x
    @picture.y = pic_y + plus_y
    # Z座標調整
    @picture.z = 1
    @picture.z = 1000 if @active_action[6]
    @picture.visible = true
  end
  #--------------------------------------------------------------------------
  # ● グラフィックファイル変更
  #--------------------------------------------------------------------------
  def graphics_change  
    # アクター限定
    return if @battler.is_a?(Game_Enemy)
    # グラフィック変更
    @battler_name = @active_action[2]
    # 戦闘後も変更を反映させるならキャラチップもここで変更
    @battler.graphic_change(@active_action[2]) unless @active_action[1]
  end  
  #--------------------------------------------------------------------------
  # ● 戦闘アニメ表示 [判別,ID,対象,反転,ウエイト,二刀フラグ]
  #--------------------------------------------------------------------------
  def battle_anime
    # エネミーの二刀フラグアニメ処理はキャンセル
    return if @active_action[5] && !@battler.actor?
    # 二刀ではないアクターの二刀フラグアニメ処理はキャンセル
    return if @active_action[5] && @battler.weapons[1] == nil
    # 二刀で右(上に配置された)武器がなく左(下に配置)だけ持ってる場合
    if @battler.actor?
      return if !@active_action[5] && @battler.weapons[0] == nil && @battler.weapons[1] != nil
    end
    anime_id = @active_action[1]
    # バックアタック時にアニメ画像を反転
    if $back_attack
      mirror = true if @active_action[3] == false
      mirror = false if @active_action[3]
    end
    # ウエイト設定
    @wait = $data_animations[anime_id].frame_max * 4 if @active_action[4]
    # 武器とスキルアニメの場合
    if anime_id < 0
      # 行動の種類でアニメ先を分岐
      if @battler.action.skill? && anime_id != -2
        anime_id = @battler.action.skill.animation_id
      elsif @battler.action.item? && anime_id != -2
        anime_id = @battler.action.item.animation_id
      else
        # 武器がなければ素手アニメを使用
        anime_id = N01::NO_WEAPON
        if @battler.actor?
          weapon_id = @battler.weapon_id
          anime_id = $data_weapons[weapon_id].animation_id if weapon_id != 0
          # 二刀アニメの場合
          anime_id = @battler.atk_animation_id2 if @active_action[5]
        else
          weapon_id = @battler.weapon
          anime_id = $data_weapons[weapon_id].animation_id if weapon_id != 0
        end
      end
      # ダメージ表示のアニメなら、ダメージ計算を先に済ませるため処理を中断
      damage_action = [anime_id, mirror, true]
      return @battler.play = ["対象アニメ",damage_action] if @battler.active
    end
    # アニメ実行
    if @active_action[2] == 0 && $data_animations[anime_id] != nil
      @battler.animation_id = anime_id
      @battler.animation_mirror = mirror
    elsif $data_animations[anime_id] != nil
      for target in @target_battler
        target.animation_id = anime_id
        target.animation_mirror = mirror
      end  
    end
  end
  #--------------------------------------------------------------------------
  # ● ふきだしアニメ表示
  #--------------------------------------------------------------------------
  def balloon_anime
    return if self.opacity == 0
    if @balloon == nil
      @balloon = Sprite.new
      @balloon.bitmap = Cache.system("Balloon")
      @balloon_height = @height * 5 / 4 if @anime_flug
      @balloon_height = @height unless @anime_flug
    end
    @balloon_id = @active_action[1]
    @balloon_loop = @active_action[2]
    @balloon_duration = 64
    @balloon_back = false
    update_balloon
    @balloon.visible = true
  end  
  #--------------------------------------------------------------------------
  # ● BGM/BGS/SE演奏
  #--------------------------------------------------------------------------
  def sound  
    # 情報を取得
    pitch = @active_action[2]
    vol =  @active_action[3]
    name = @active_action[4]
    # 実行
    case @active_action[1]
    when "se"
      Audio.se_play("Audio/SE/" + name, vol, pitch)
    when "bgm"
      # 名前指定のない場合、現在のBGMを変えないように
      if @active_action[4] == ""
        now_bgm = RPG::BGM.last
        name = now_bgm.name
      end
      Audio.bgm_play("Audio/BGM/" + name, vol, pitch)
    when "bgs"
      # 名前指定のない場合、現在のBGSを変えないように
      if @active_action[4] == ""
        now_bgs = RPG::BGS.last
        name = now_bgs.name
      end
      Audio.bgs_play("Audio/BGS/" + name, vol, pitch)
    end
  end
  #--------------------------------------------------------------------------
  # ● ゲーム変数操作
  #--------------------------------------------------------------------------
  def variable
    # オペランドチェック
    operand = @active_action[3]
    # 変数操作で分岐
    case @active_action[2]
    when 0 # 代入
      $game_variables[@active_action[1]] = operand
    when 1 # 加算
      $game_variables[@active_action[1]] += operand
    when 2 # 減算
      $game_variables[@active_action[1]] -= operand
    when 3 # 乗算
      $game_variables[@active_action[1]] *= operand
    when 4 # 除算
      $game_variables[@active_action[1]] /= operand
    when 5 # 剰余
      $game_variables[@active_action[1]] %= operand
    end
  end  
  #--------------------------------------------------------------------------
  # ● 二刀限定
  #--------------------------------------------------------------------------
  def two_swords
    # エネミーは処理させない
    return @action.shift unless @battler.actor?
    # 左(下部表示)に武器がなかったら次のアクションを除く
    return @action.shift if @battler.weapons[1] == nil
    # 行動配列の先頭からシフト
    active = @action.shift
    # 現在のアクションを決定
    @active_action = N01::ANIME[active]
    # ウエイト設定
    @wait = active.to_i if @active_action == nil
    # 単発アクション開始
    action
  end
  #--------------------------------------------------------------------------
  # ● 非二刀限定
  #--------------------------------------------------------------------------
  def non_two_swords
    # エネミーは処理させない
    return unless @battler.actor?
    # 左(下部表示)に武器があったら次のアクションを除く
    return @action.shift if @battler.weapons[1] != nil
    # 行動配列の先頭からシフト
    active = @action.shift
    # 現在のアクションを決定
    @active_action = N01::ANIME[active]
    # ウエイト設定
    @wait = active.to_i if @active_action == nil
    # 単発アクション開始
    action
  end
  #--------------------------------------------------------------------------
  # ● アクション条件
  #--------------------------------------------------------------------------
  def necessary
    nece1 = @active_action[3]
    nece2 = @active_action[4]
    # ターゲットチェック
    case @active_action[1]
    # 0自身 1ターゲット 2敵全体 3味方全体
    when 0
      target = [$game_party.members[@battler.index]] if @battler.is_a?(Game_Actor)
      target = [$game_troop.members[@battler.index]] if @battler.is_a?(Game_Enemy)
    when 1
      target = @target_battler
    when 2
      target = $game_troop.members
    when 3
      target = $game_party.members
    end
    # ターゲットが空の場合は失敗とみなす
    return start_action(@battler.recover_action) if target.size == 0
    # 内容チェック
    case @active_action[2]
    # ステートID指定だった場合
    when 0
      # 補足が正で「ステートにかかっている」、負は「かかっていない」が条件に
      state_on = true if nece2 > 0
      # 条件人数を出す
      state_member = nece2.abs
      # 0は仲間数を出す
      if nece2 == 0
        state_member = $game_party.members.size if @battler.is_a?(Game_Actor)
        state_member = $game_troop.members.size if @battler.is_a?(Game_Enemy)
      end  
      # ターゲットのステートチェックし人数をカウント
      for member in target
        state_member -= 1 if member.state?(nece1)
      end
      # 条件が満たされていればアクション続行
      if state_member == 0 && state_on
        return
      elsif state_member == nece2.abs
        return if state_on == nil
      end  
    # パラメータ指定だった場合
    when 1  
      # 補足が正で「数値以上」、負は「数値以下」が条件に
      num_over = true if nece2 > 0
      # 参照数値
      num = 0
      # ターゲットのパラメータチェック
      for member in target
        # 参照パラメータで分岐
        case  nece1
        when 0 # 現HP
          num += member.hp
        when 1 # 現MP
          num += member.mp
        when 2 # 攻撃力
          num += member.atk
        when 3 # 防御力
          num += member.def
        when 4 # 精神力
          num += member.spi
        when 5 # 敏捷性
          num += member.agi
        end
      end
      # 平均を出す
      num = num / target.size
      # 条件が満たされていればアクション続行
      if num > nece2.abs && num_over
        return
      elsif num < nece2.abs
        return if num_over == nil
      end
    # スイッチ指定だった場合
    when 2
      # 条件が満たされていればアクション続行
      if $game_switches[nece1]
        # 補足がtrueで「スイッチON」、falseは「スイッチOFF」が条件に
        return if nece2
      # スイッチがOFFの場合はON時とは逆に  
      else
        return unless nece2
      end  
    # 変数指定だった場合
    when 3
      # 補足が正で「数値以上」、負は「数値以下」が条件に
      if nece2 > 0
        return if $game_variables[nece1] > nece2
      else
        return unless $game_variables[nece1] > nece2.abs
      end
    # 習得スキル指定だった場合
    when 4
      # スキル条件人数を出す
      skill_member = nece2.abs
      for member in target
        skill_member -= 1 if member.skill_learn?(nece1)
        # 条件確認
        return if skill_member == 0
      end  
    end
    # 条件を満たせなければ以降のアクションを中断
    return @action = ["終了"] if @non_repeat
    # 防御中は不自然に見えないように座標復帰させない
    action = @battler.recover_action
    action = @battler.defence if @battler.guarding?
    return start_action(action)
  end  
  #--------------------------------------------------------------------------
  # ● スキル派生
  #--------------------------------------------------------------------------
  def derivating
    # 未修得スキルは派生不可なら
    return unless @active_action[2] && !@battler.skill_learn?(@active_action[3])
    # 確率分岐
    return if rand(100) > @active_action[1]
    # 派生成功
    @battler.derivation = @active_action[3]
    # 以降のアクションを中断
    @action = ["終了"]
  end
  #--------------------------------------------------------------------------
  # ● 個別処理開始
  #--------------------------------------------------------------------------
  def individual_action
    # リピートフラグオン
    @battler.individual = true
    # リピートアクションを保持
    @individual_act = @action.dup
    # ターゲットを保持し、行動ターゲットをひとつずつ抜き出す
    send_action(["個別処理"])
    @individual_targets = @target_battler.dup
    @target_battler = [@individual_targets.shift]
  end
  #--------------------------------------------------------------------------
  # ● 個別処理終了
  #--------------------------------------------------------------------------
  def individual_action_end
    # ターゲットが残っていないなら行動終了
    return @battler.individual = false if @individual_targets.size == 0
    @action = @individual_act.dup
    @target_battler = [@individual_targets.shift]
  end  
  #--------------------------------------------------------------------------
  # ● 待機に移行しない
  #--------------------------------------------------------------------------
  def non_repeat
    @repeat_action = []
    @non_repeat = true
    anime_finish
  end  
  #--------------------------------------------------------------------------
  # ● ターゲット変更 action = [判別, 変更する対象, 変更先]
  #--------------------------------------------------------------------------
  def change_target
    # 自身の変更したターゲットを元に戻す
    return @target_battler = @now_targets.dup if @active_action[2] == 3
    # 送るターゲット情報
    target = [@battler] if @active_action[2] == 0
    target = @target_battler.dup if @active_action[2] != 0
    # 自身のターゲットを送った相手にする場合、現在のターゲットを記憶
    if @active_action[2] == 2
      @now_targets = @target_battler.dup
      @target_battler = []
    end  
    # 送るターゲットがインデックス指定の場合
    if @active_action[1] >= 1000
      members = $game_party.members if @battler.actor?
      members = $game_troop.members unless @battler.actor?
      index = @active_action[1] - 1000
      if index < members.size
        if members[index].exist? && @battler.index != index
          # ターゲット変更
          members[index].force_target = ["N01target_change", target]
          # 自身のターゲットを送った相手にする場合
          @target_battler = [members[index]] if @active_action[2] == 2
          change = true
        else
          for member in members
            next if @battler.index == member.index
            next unless member.exist?
            member.force_target = ["N01target_change", target]
            @target_battler = [member] if @active_action[2] == 2
            break change = true
          end
        end
      end
    # 送るターゲットがステートID指定だった場合
    elsif @active_action[1] > 0
      for member in $game_party.members + $game_troop.members
        if member.state?(@active_action[1])
          member.force_target = ["N01target_change", target]
          @target_battler.push(member) if @active_action[2] == 2
          change = true
        end  
      end  
    # 送るターゲットが習得スキル指定だった場合
    elsif @active_action[1] < 0
      skill_id = @active_action[1].abs
      for actor in $game_party.members
        if actor.skill_learn?(skill_id)
          actor.force_target = ["N01target_change", target]
          @target_battler.push(target) if @active_action[2] == 2
          change = true
        end  
      end
    # 送るターゲットがターゲットだった場合
    else
      for member in @target_battler
        member.force_target = ["N01target_change", target]
        @target_battler.push(member) if @active_action[2] == 2
        change = true
      end
    end
    # 条件を満たせなければ以降のアクションを中断
    return if change
    return @action = ["終了"] if @non_repeat
    return start_action(@battler.recover_action)
  end    
  #--------------------------------------------------------------------------
  # ● ステート付与
  #--------------------------------------------------------------------------
  def state_on  
    state_id = @active_action[2]
    # 対象で分岐
    case @active_action[1]
    when 0
      @battler.add_state(state_id)
    when 1
      if @target_battler != nil
        for target in @target_battler
          target.add_state(state_id)
        end
      end
    when 2
      for target in $game_troop.members
        target.add_state(state_id)
      end
    when 3
      for target in $game_party.members
        target.add_state(state_id)
      end
    when 4
      for target in $game_party.members
        if target.index != @battler.index
          target.add_state(state_id)
        end  
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● ステート解除
  #--------------------------------------------------------------------------
  def state_off  
    state_id = @active_action[2]
    # 対象で分岐
    case @active_action[1]
    when 0
      @battler.remove_state(state_id)
    when 1
      if @target_battler != nil
        for target in @target_battler
          target.remove_state(state_id)
        end
      end
    when 2
      for target in $game_troop.members
        target.remove_state(state_id)
      end
    when 3
      for target in $game_party.members
        target.remove_state(state_id)
      end
    when 4
      for target in $game_party.members
        if target.index != @battler.index
          target.remove_state(state_id)
        end  
      end
    end
  end  
  #--------------------------------------------------------------------------
  # ● 浮遊実行
  #--------------------------------------------------------------------------
  def floating  
    # ジャンプを初期化
    jump_reset
    # 情報確認
    @jump_plus = @active_action[1]
    float_end = @active_action[2]
    @float_time = @active_action[3]
    # １フレーム当たりの移動高度を計算
    @float_up = (float_end - @jump_plus)/ @float_time
    # 浮遊が完了するまで次のアクションに行かない
    @wait = @float_time
    # 浮遊アニメ設定を反映
    if @anime_flug
      move_anime = N01::ANIME[@active_action[4]]
      # グラフィック指定がない場合はスキップ
      if move_anime != nil
        # 現在のアクションを上書き
        @active_action = move_anime
        # バトラーアニメ開始
        battler_anime
        # 浮遊が完了したら即アニメが終わるように
        @anime_end = true
      end
    end
    # 初期高度に浮遊
    @battler.jump = @jump_plus
  end      
  #--------------------------------------------------------------------------
  # ● 強制アクション
  #--------------------------------------------------------------------------
  def force_action
    # アクションが単発か通しか判別
    kind = @active_action[0]
    # 復帰の有無をチェック
    rebirth = @active_action[2]
    # 強制アクション内容を取得
    play = @active_action[3]
    # 上3つの情報をまとめて格納
    action = [kind,rebirth,play]
    # ターゲットがインデックス指定の場合
    if @active_action[1] >= 1000
      members = $game_party.members if @battler.actor?
      members = $game_troop.members unless @battler.actor?
      index = @active_action[1] - 1000
      if index < members.size
        if members[index].exist? && @battler.index != index
          # バトラー情報に渡す
          return members[index].force_action = action
        else
          for target in members
            next if @battler.index == target.index
            next unless target.exist?
            force = true
            break target.force_action = action
          end
        end
      end
      # 条件を満たせなければ以降のアクションを中断
      return if force
      return @action = ["終了"] if @non_repeat
      return start_action(@battler.recover_action)
    # ターゲット指定の場合  
    elsif @active_action[1] == 0
      for target in @target_battler
        target.force_action = action if target != nil
      end
    # ステートID指定だった場合  
    elsif @active_action[1] > 0
      for target in $game_party.members + $game_troop.members
        target.force_action = action if target.state?(@active_action[1])
      end
    # 習得スキル指定だった場合  
    elsif @active_action[1] < 0  
      # エネミーは処理させない
      return if @battler.is_a?(Game_Enemy)
      for actor in $game_party.members
        # 自分は除く
        unless actor.id == @battler.id
          # バトラー情報に渡す
          actor.force_action = action if actor.skill_id_learn?(@active_action[1].abs)
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● 座標リセット実行
  #--------------------------------------------------------------------------
  def reseting
    # ジャンプを初期化
    jump_reset
    # 回転を元に戻す
    self.angle = 0
    # 情報確認
    @distanse_x   = @move_x * -1
    @distanse_y   = @move_y * -1
    @move_speed_x = @active_action[1]
    @move_speed_y = @move_speed_x
    @move_boost_x = @active_action[2]
    @move_boost_y = @move_boost_x
    @jump         = @active_action[3]
    # 移動計算
    move_distance
    # 移動アニメ設定を反映
    if @anime_flug
      move_anime = N01::ANIME[@active_action[4]]
      # グラフィック指定がない場合はスキップ
      if move_anime != nil
        # 現在のアクションを上書き
        @active_action = move_anime
        # バトラーアニメ開始
        battler_anime
      end
      # 移動が完了したら即アニメが終わるように
      @anime_end = true
    end
  end
  #--------------------------------------------------------------------------
  # ● 移動実行
  #--------------------------------------------------------------------------
  def moving  
    # ジャンプを初期化
    jump_reset
    # X軸移動を便宜上抜き出す
    xx = @active_action[1]
    # バックアタック時にはX軸を逆に
    xx *= -1 if $back_attack
    # 移動目標のターゲットを確認
    case @active_action[0]
    when 0 # 自身
      @distanse_x = xx
      @distanse_y = @active_action[2]
    when 1 # ターゲット
      # ターゲットが決まってない場合、自身に変換
      if @target_battler == nil
        @distanse_x = xx
        @distanse_y = @active_action[2]
      else
        # ターゲット対象をひとつずつチェック
        target_x = 0
        target_y = 0
        time = 0
        for i in 0...@target_battler.size
          if @target_battler[i] != nil
            time += 1
            target_x += @target_battler[i].position_x
            target_y += @target_battler[i].position_y
          end  
        end
        # ターゲットが空だった場合、自身に変換
        if time == 0
          @distanse_x = xx
          @distanse_y = @active_action[2]
        else  
          # 複数ターゲットの中心を計算
          target_x = target_x / time
          target_y = target_y / time
          # 最終的な移動距離を算出
          @distanse_y = target_y - self.y + @active_action[2]
          # X座標はアクターとエネミーで逆計算
          if @battler.is_a?(Game_Actor)
            @distanse_x = target_x - self.x + xx
          else
            @distanse_x = self.x - target_x + xx
          end  
        end  
      end  
    when 2 # 画面
      # X座標はアクターとエネミーで逆計算
      if @battler.is_a?(Game_Actor)
        @distanse_x = xx - self.x
        @distanse_x = N01::GAME_SCREEN[0] + xx - self.x if $back_attack
      else
        @distanse_x = self.x - xx
        @distanse_x = self.x - (N01::GAME_SCREEN[0] + xx) if $back_attack
      end
      @distanse_y = @active_action[2] - self.y
    when 3 # 初期位置
      # X座標はアクターとエネミーで逆計算
      if @battler.is_a?(Game_Actor)
        @distanse_x = xx + @battler.base_position_x - self.x
      else
        @distanse_x = xx + self.x - @battler.base_position_x
      end
      @distanse_y = @active_action[2] + @battler.base_position_y - @battler.position_y
    end
    @move_speed_x = @active_action[3]
    @move_speed_y = @active_action[3]
    @move_boost_x = @active_action[4]
    @move_boost_y = @active_action[4]
    @jump         = @active_action[5]
    @jump_plus = 0
    # 移動計算
    move_distance
    # 移動アニメ設定を反映
    if @anime_flug
      move_anime = N01::ANIME[@active_action[6]]
      # グラフィック指定がない場合はスキップ
      if move_anime != nil
        # 現在のアクションを上書き
        @active_action = move_anime
        # バトラーアニメ開始
        battler_anime
      end  
      # 移動が完了したら即アニメが終わるように
      @anime_end = true
    end
  end
  #--------------------------------------------------------------------------
  # ● 移動計算
  #--------------------------------------------------------------------------
  def move_distance
    # 速度が0の場合、その場に留まる
    if @move_speed_x == 0
      @moving_x = 0
      @moving_y = 0
    else  
      # １フレームあたりの移動距離を計算
      @moving_x = @distanse_x / @move_speed_x
      @moving_y = @distanse_y / @move_speed_y
      # 余った距離はこの時点で移動し消化
      over_x = @distanse_x % @move_speed_x
      over_y = @distanse_y % @move_speed_y
      @move_x += over_x
      @move_y += over_y
      @battler.move_x = @move_x
      @battler.move_y = @move_y
      @distanse_x -= over_x
      @distanse_y -= over_y
    end  
    # 移動があるかどうかの判定
    if @distanse_x == 0
      @move_speed_x = 0
    end
    if @distanse_y == 0
      @move_speed_y = 0
    end
    # X座標移動計算
    # 加減速による移動フレーム数の修正
    boost_x = @moving_x
    move_x = 0
    # 加速がある場合
    if @move_boost_x > 0 && @distanse_x != 0
      # 加減速の正負を左右移動に合わせて変換
      if @distanse_x == 0
        @move_boost_x = 0
      elsif @distanse_x < 0
        @move_boost_x *= -1
      end
      # 距離の変化を事前計算
      for i in 0...@move_speed_x
        boost_x += @move_boost_x
        move_x += boost_x
        # オーバー距離を記録
        over_distance = @distanse_x - move_x
        # 右移動で距離オーバーする直前が何フレーム目だったか記録
        if @distanse_x > 0 && over_distance < 0
          @move_speed_x = i
          break
        # 左移動で距離オーバーする直前が何フレーム目だったか記録
        elsif @distanse_x < 0 && over_distance > 0
          @move_speed_x = i
          break
        end
      end
      # オーバー距離を一回前に戻す
      before = over_distance + boost_x
      # 余った距離を等速移動させるフレーム数を加算
      @move_speed_plus_x = (before / @moving_x).abs
      # それでも余った距離はこの時点で移動し消化
      @move_x += before % @moving_x
      @battler.move_x = @move_x
    # 減速がある場合  
    elsif @move_boost_x < 0 && @distanse_x != 0
      # 加減速の正負を左右移動に合わせて変換
      if @distanse_x == 0
        @move_boost_x = 0
      elsif @distanse_x < 0
        @move_boost_x *= -1
      end
      # 距離の変化を事前計算
      for i in 0...@move_speed_x
        boost_x += @move_boost_x
        move_x += boost_x
        # 足りない距離を記録
        lost_distance = @distanse_x - move_x
        before = lost_distance
        # 右移動で速度が0になる直前が何フレーム目だったか記録
        if @distanse_x > 0 && boost_x < 0
          @move_speed_x = i - 1
          # 足りない距離を一回前に戻す
          before = lost_distance + boost_x
          break
        # 左移動で速度が0になる直前が何フレーム目だったか記録
        elsif @distanse_x < 0 && boost_x > 0
          @move_speed_x= i - 1
          # 足りない距離を一回前に戻す
          before = lost_distance + boost_x
          break
        end
      end
      # 足りない距離を等速移動させるフレーム数を加算
      plus = before / @moving_x
      @move_speed_plus_x = plus.abs
      # それでも余った距離はこの時点で移動し消化
      @move_x += before % @moving_x
      @battler.move_x = @move_x
    end
    # Y座標移動計算
    # 加減速による移動フレーム数の修正
    boost_y = @moving_y
    move_y = 0
    # 加速がある場合
    if @move_boost_y > 0 && @distanse_y != 0
      # 加減速の正負を左右移動に合わせて変換
      if @distanse_y == 0
        @move_boost_y = 0
      elsif @distanse_y < 0
        @move_boost_y *= -1
      end
      # 距離の変化を事前計算
      for i in 0...@move_speed_y
        boost_y += @move_boost_y
        move_y += boost_y
        # オーバー距離を記録
        over_distance = @distanse_y - move_y
        # 右移動で距離オーバーする直前が何フレーム目だったか記録
        if @distanse_y > 0 && over_distance < 0
          @move_speed_y = i
          break
        # 左移動で距離オーバーする直前が何フレーム目だったか記録
        elsif @distanse_y < 0 && over_distance > 0
          @move_speed_y = i
          break
        end
      end
      # オーバー距離を一回前に戻す
      before = over_distance + boost_y
      # 余った距離を等速移動させるフレーム数を加算
      @move_speed_plus_y = (before / @moving_y).abs
      # それでも余った距離はこの時点で移動し消化
      @move_y += before % @moving_y
      @battler.move_y = @move_y
    # 減速がある場合  
    elsif @move_boost_y < 0 && @distanse_y != 0
      # 加減速の正負を左右移動に合わせて変換
      if @distanse_y == 0
        @move_boost_y = 0
      elsif @distanse_y < 0
        @move_boost_y *= -1
      end
      # 距離の変化を事前計算
      for i in 0...@move_speed_y
        boost_y += @move_boost_y
        move_y += boost_y
        # 足りない距離を記録
        lost_distance = @distanse_y - move_y
        before = lost_distance
        # 右移動で速度が0になる直前が何フレーム目だったか記録
        if @distanse_y > 0 && boost_y < 0
          @move_speed_y = i
          # 足りない距離を一回前に戻す
          before = lost_distance + boost_y
          break
        # 左移動で速度が0になる直前が何フレーム目だったか記録
        elsif @distanse_y < 0 && boost_y > 0
          @move_speed_y = i
          # 足りない距離を一回前に戻す
          before = lost_distance + boost_y
          break
        end
      end
      # 足りない距離を等速移動させるフレーム数を加算
      plus = before / @moving_y
      @move_speed_plus_y = plus.abs
      # それでも余った距離はこの時点で移動し消化
      @move_y += before % @moving_y
      @battler.move_y = @move_y
    end
    # 移動完了時間を算出
    x = @move_speed_plus_x + @move_speed_x
    y = @move_speed_plus_y + @move_speed_y
    if x > y
      end_time = x
    else
      end_time = y
    end
    # 移動が完了するまで次のアクションに行かない
    @wait = end_time
    # ジャンプ計算
    if @jump != 0
      # 移動がなくジャンプのみの場合
      if @wait == 0
        # 時間に計上
        @wait = @active_action[3]
      end  
      # 移動完了時間からジャンプ時間を算出
      @jump_time = @wait / 2
      # 割り切れない場合の余り時間
      @jump_time_plus = @wait % 2
      # ジャンプの正負を判別
      @jump_sign = 0
      @jump_sign2 = 0
      if @jump < 0
        @jump_sign = -1
        @jump_sign2 = 1
        @jump = @jump * -1
      else
        @jump_sign = 1
        @jump_sign2 = -1
      end
      # ジャンプ初速度を決定
      @jump_up = 2 ** @jump * @jump_sign
      # ジャンプ時間の端数を微調整
      if @jump_time == 0
        @jump_up = 0
      elsif @jump_time != 1
        @jump_size = @jump_up * @jump_sign * @jump_sign2
      else
        @jump_size = @jump_up * 2 * @jump_sign * @jump_sign2
        @jump_flug = true
      end  
    end
  end
  #--------------------------------------------------------------------------
  # ● バトラーアニメ開始
  #--------------------------------------------------------------------------
  def battler_anime
    # アニメ設定を反映
    @anime_kind  = @active_action[1]
    @anime_speed = @active_action[2]
    @anime_loop  = @active_action[3]
    # ウエイト時間があれば加算
    @unloop_wait = @active_action[4]
    @anime_end = false
    # 武器アクションがある場合だけ更新する
    if @weapon_R != nil && @active_action[8] != ""
      # 武器の設定をチェック
      weapon_kind = N01::ANIME[@active_action[8]]
      # エネミーと二刀ではないアクターの二刀フラグアニメ処理はキャンセル
      two_swords_flug = weapon_kind[11]
      return if two_swords_flug && !@battler.actor?
      return if two_swords_flug && @battler.weapons[1] == nil && @battler.actor?
      if @battler.actor? && @battler.weapons[0] == nil && !two_swords_flug
        @weapon_R.action_reset
      elsif @battler.actor? && @battler.weapons[1] == nil && two_swords_flug
        @weapon_R.action_reset
      elsif !@battler.actor? && @battler.weapon == 0
        @weapon_R.action_reset
      else
        # 初期化
        @weapon_R.action_reset
        # 武器画像を設定
        @weapon_R.weapon_graphics unless two_swords_flug
        @weapon_R.weapon_graphics(true) if two_swords_flug
        # 武器アクションを渡す
        @weapon_R.weapon_action(@active_action[8],@anime_loop)
        @weapon_action = true
        # 最初の武器アクションを更新
        @weapon_R.action
      end
    elsif @weapon_R != nil
      @weapon_R.action_reset
    end  
    # アニメパターンが固定だった場合
    if @active_action[5] != -1
      # フラグオン
      @anime_freeze = true
      # アニメが常に終了しているとみなす
      @anime_end = true
    # 通常のアニメ更新の場合  
    else  
      @anime_freeze = false
      # 最初のアニメパターンを更新
      @pattern = 0
      # 武器アニメがある時だけフレーム更新
      if @weapon_action && @weapon_R != nil
        @weapon_R.action
        @weapon_R.update
      end
    end  
    @pattern_back = false
    @frame = @anime_speed
    # Z座標設定
    @battler.move_z = @active_action[6]
    # 影の有無
    if @shadow != nil
      @shadow.visible = true if @active_action[7]
      @shadow.visible = false unless @active_action[7]
      @shadow.visible = false if @skip_shadow
    end
    # ナンバリングから読み取るファイル名を分岐
    if @active_action[0] == 0
      file_name = @battler_name
    else
      file_name = @battler_name + "_" + @active_action[0].to_s
    end  
    # アニメしないバトラーなら処理終了
    return unless @anime_flug
    self.bitmap = Cache.character(file_name)
    # 転送元の矩形を設定
    @sx = @pattern * @width
    @sy = @anime_kind * @height
    @sx = @active_action[5] * @width if @anime_freeze
    self.src_rect.set(@sx, @sy, @width, @height)
  end
  #--------------------------------------------------------------------------
  # ● アニメ飛ばし
  #--------------------------------------------------------------------------
  def moving_anime
    # まだ前のアニメ飛ばしが残っているなら初期化
    @move_anime.action_reset if @anime_moving
    @anime_moving = true
    # バックアタック中はアニメ、武器画像反転
    mirror = false
    mirror = true if $back_attack
    # アニメID
    id = @active_action[1]
    # 対象
    target = @active_action[2]
    x = y = mem = 0
    # 対象が単体の場合
    if target == 0
      # ターゲットが決まってない場合、自身に変換
      if @target_battler == nil
        x = self.x
        y = self.y
      else
        # ターゲットが空の場合、自身に変換
        if @target_battler[0] == nil
          x = self.x
          y = self.y
        else  
          # 最初に入っているターゲットに対象決定
          x = @target_battler[0].position_x
          y = @target_battler[0].position_y
        end  
      end  
    # 対象が敵の中心の場合  
    elsif target == 1
      # 自身がアクターの場合はエネミーの中心を計算
      if @battler.is_a?(Game_Actor)
        for target in $game_troop.members
          x += target.position_x
          y += target.position_y
          mem += 1
        end
        x = x / mem
        y = y / mem
      # 自身がエネミーの場合はアクターの中心を計算
      else
        for target in $game_party.members
          x += target.position_x
          y += target.position_y
          mem += 1
        end
        x = x / mem
        y = y / mem
      end
    # 対象が味方の中心の場合  
    elsif target == 2
      # 自身がアクターの場合はアクターの中心を計算
      if @battler.is_a?(Game_Actor)
        for target in $game_party.members
          x += target.position_x
          y += target.position_y
          mem += 1
        end
        x = x / mem
        y = y / mem
      # 自身がエネミーの場合はエネミーの中心を計算
      else
        for target in $game_troop.members
          x += target.position_x
          y += target.position_y
          mem += 1
        end
        x = x / mem
        y = y / mem
      end
    # 対象が自身の場合  
    else
      x = self.x
      y = self.y
    end  
    # 開始位置の微調整
    plus_x = @active_action[6]
    plus_y = @active_action[7]
    # エネミーはX軸を逆に
    plus_x *= -1 if @battler.is_a?(Game_Enemy)
    # 最終的な移動距離を算出
    distanse_x = x - self.x - plus_x
    distanse_y = y - self.y - plus_y
    # 飛ばしタイプ
    type = @active_action[3]
    # 速度
    speed = @active_action[4]
    # 軌道
    orbit = @active_action[5]
    # 自身が開始位置なら
    if @active_action[8] == 0
      @move_anime.base_x = self.x + plus_x
      @move_anime.base_y = self.y + plus_y
    # 対象が開始位置なら
    elsif @active_action[8] == 1
      @move_anime.base_x = x + plus_x
      @move_anime.base_y = y + plus_y
      # 距離を反対に
      distanse_y = distanse_y * -1
      distanse_x = distanse_x * -1
    # 動かさないなら
    else
      @move_anime.base_x = x
      @move_anime.base_y = y
      distanse_x = distanse_y = 0
    end
    # 武器アクションなしは武器表示しない
    if @active_action[10] == ""
      weapon = ""  
    # アニメなしエネミーは武器表示しない
    elsif @anime_flug != true
      weapon = ""  
    # 武器アクションがある場合
    else
      # 飛ばす武器グラフィックが指定されているかチェック
      if @battler.is_a?(Game_Actor)
        battler = $game_party.members[@battler.index]
        weapon_id = battler.weapon_id
      else  
        battler = $game_troop.members[@battler.index]
        weapon_id = battler.weapon
      end  
      # 素手でなければ
      if weapon_id != 0
        weapon_file = $data_weapons[weapon_id].flying_graphic
        # 別画像が指定されていなければ既存の武器グラフィックを取得
        if weapon_file == ""
          weapon_name = $data_weapons[weapon_id].graphic
          icon_weapon = false
          # さらに指定がなければアイコングラフィックを利用
          if weapon_name == ""
            weapon_name = $data_weapons[weapon_id].icon_index
            icon_weapon = true
          end  
        # 指定されていればそのグラフィック名を取得  
        else
          icon_weapon = false
          weapon_name = weapon_file
        end
        # 武器アクション情報を取得
        weapon = @active_action[10]
      # 素手なら表示しない
      else
        weapon = ""
      end
    end
    # Z座標を決定
    @move_anime.z = 1
    @move_anime.z = 1000 if @active_action[9]
    # 以上の情報を全てアニメ飛ばしスプライトに送る
    @move_anime.anime_action(id,mirror,distanse_x,distanse_y,type,speed,orbit,weapon,weapon_name,icon_wea
pon)
  end  
  #--------------------------------------------------------------------------
  # ● アクション終了
  #--------------------------------------------------------------------------
  def anime_finish
    # 個別処理終了が省略された場合リピートさせる
    return individual_action_end if @individual_targets.size != 0
    # アクティブバトラーにアクション情報を格納
    send_action(@active_action[0]) if @battler.active
    # 残像があれば開放
    mirage_off if @mirage_flug
    # 待機アクションを繰り返す
    start_action(@repeat_action) unless @non_repeat
  end  
  #--------------------------------------------------------------------------
  # ● コラプスアクション
  #--------------------------------------------------------------------------
  def collapse_action
    @non_repeat = true
    @effect_type = COLLAPSE
    @collapse_type = @battler.collapse_type unless @battler.actor?
    @effect_duration = N01::COLLAPSE_WAIT + 48 if @collapse_type == 2
    @effect_duration = 401 if @collapse_type == 3
  end  
  #--------------------------------------------------------------------------
  # ● ノーマルコラプス
  #--------------------------------------------------------------------------
  def normal_collapse
    if @effect_duration == 47
      Sound.play_enemy_collapse
      self.blend_type = 1
      self.color.set(255, 128, 128, 128)
    end
    self.opacity = 256 - (48 - @effect_duration) * 6 if @effect_duration <= 47
  end  
  #--------------------------------------------------------------------------
  # ● ボスコラプス
  #--------------------------------------------------------------------------
  def boss_collapse1
    if @effect_duration == 320
      Audio.se_play("Audio/SE/Absorb1", 100, 80)
      self.flash(Color.new(255, 255, 255), 60)
      viewport.flash(Color.new(255, 255, 255), 20)
    end
    if @effect_duration == 280
      Audio.se_play("Audio/SE/Absorb1", 100, 80)
      self.flash(Color.new(255, 255, 255), 60)
      viewport.flash(Color.new(255, 255, 255), 20)
    end
    if @effect_duration == 220
      Audio.se_play("Audio/SE/Earth4", 100, 80)
      reset
      self.blend_type = 1
      self.color.set(255, 128, 128, 128)
      self.wave_amp = 6
    end
    if @effect_duration < 220
      self.src_rect.set(0, @effect_duration / 2 - 110, @width, @height)
      self.x += 8 if @effect_duration % 4 == 0
      self.x -= 8 if @effect_duration % 4 == 2
      self.wave_amp += 1 if @effect_duration % 10 == 0
      self.opacity = @effect_duration
      return if @effect_duration < 50
      Audio.se_play("Audio/SE/Earth4", 100, 50) if @effect_duration % 50 == 0
    end
  end
end

And finally:

[Show/Hide] Code3

CODE

#==============================================================================
# ■ Scene_Battle ver1.2
#------------------------------------------------------------------------------
# 　バトル画面の処理を行うクラスです。
#==============================================================================
class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  # ● 終了処理
  #--------------------------------------------------------------------------
  alias terminate_n01 terminate
  def terminate
    terminate_n01
    # 二刀流の持ち替え処理を戻す
    for member in $game_party.members
      if member.two_swords_change
        member.change_equip_by_id(1, member.weapon_id)
        member.change_equip_by_id(0, 0)
        member.two_swords_change = false
      end  
    end
  end
  #--------------------------------------------------------------------------
  # ● 戦闘開始の処理
  #--------------------------------------------------------------------------
  alias process_battle_start_n01 process_battle_start
  def process_battle_start
    process_battle_start_n01
    # 二刀流で左(下部表示)に武器を持ち右(上部表示)に武器を持たないように
    # している場合、ここで強制的に持ち替えさせる
    for member in $game_party.members
      if member.weapons[0] == nil and member.weapons[1] != nil
        member.change_equip_by_id(0, member.armor1_id)
        member.change_equip_by_id(1, 0)
        member.two_swords_change = true
      end
    end  
  end
  #--------------------------------------------------------------------------
  # ● ヘルプウインドウの表示
  #--------------------------------------------------------------------------
  def pop_help(obj)
    return if obj.extension.include?("ヘルプ非表示")
    @help_window.set_text(obj.name, 1)
    @help_window.visible = true
  end
  #--------------------------------------------------------------------------
  # ● 情報表示ビューポートの移動
  #--------------------------------------------------------------------------
  def move1_info_viewport
    @info_viewport.ox = 128
    loop do
      update_basic
      @info_viewport.ox -= 8
      @party_command_window.x -= 8
      @actor_command_window.x += 8
      break if @info_viewport.ox == 64
    end  
  end
  #--------------------------------------------------------------------------
  # ● 情報表示ビューポートの移動
  #--------------------------------------------------------------------------
  def move2_info_viewport
    @info_viewport.ox = 64
    loop do
      update_basic
      @info_viewport.ox -= 8
      @party_command_window.x += 8
      @actor_command_window.x -= 8
      break if @info_viewport.ox == 0
    end  
  end
  #--------------------------------------------------------------------------
  # ● 次のアクターのコマンド入力へ
  #--------------------------------------------------------------------------
  alias next_actor_n01 next_actor
  def next_actor
    # 動けるキャラのみコマンドアクションを
    if @active_battler != nil && @active_battler.inputable?
      @spriteset.set_action(true, @actor_index,@active_battler.command_a)
    end
    # 最後のアクターの場合、アクションが終わるまで待つ
    @wait_count = 32 if @actor_index == $game_party.members.size-1
    next_actor_n01
    # 動けるキャラのみコマンドアクションを
    if @active_battler != nil && @active_battler.inputable?
      @spriteset.set_action(true, @actor_index,@active_battler.command_b)
    end
  end
  #--------------------------------------------------------------------------
  # ● 前のアクターのコマンド入力へ
  #--------------------------------------------------------------------------
  alias prior_actor_n01 prior_actor
  def prior_actor
    # 動けるキャラのみコマンドアクションを
    if @active_battler != nil && @active_battler.inputable?
      @active_battler.action.clear
      @spriteset.set_action(true, @actor_index,@active_battler.command_a)
    end
    prior_actor_n01
    # 動けるキャラのみコマンドアクションを
    if @active_battler != nil && @active_battler.inputable?
      @active_battler.action.clear
      @spriteset.set_action(true, @actor_index,@active_battler.command_b)
    end
  end  
  #--------------------------------------------------------------------------
  # ● ターゲット選択の開始  ※再定義
  #--------------------------------------------------------------------------
  def start_target_enemy_selection
    start_target_selection
  end
  #--------------------------------------------------------------------------
  # ● ターゲット選択の開始  ※再定義
  #--------------------------------------------------------------------------
  def start_target_actor_selection
    start_target_selection(true)
  end
  #--------------------------------------------------------------------------
  # ● ターゲット選択の開始
  #--------------------------------------------------------------------------
  def start_target_selection(actor = false)
    members = $game_party.members if actor
    members = $game_troop.members unless actor
    # カーソルスプライトの作成
    @cursor = Sprite.new
    @cursor.bitmap = Cache.character("cursor")
    @cursor.src_rect.set(0, 0, 32, 32)
    @cursor_flame = 0
    @cursor.x = -200
    @cursor.y = -200
    @cursor.ox = @cursor.width
    @cursor.oy = @cursor.height
    # ターゲット名を表示するヘルプウインドウを作成
    @help_window = Window_Help.new if @help_window == nil
    # 不要なウインドウを消す
    @actor_command_window.active = false
    @skill_window.visible = false if @skill_window != nil
    @item_window.visible = false if @item_window != nil
    # 存在しているターゲットで最も番号の低い対象を最初に指すように
    @index = 0
    @max_index = members.size - 1
    # アクターは戦闘不能者でもターゲットできるようにエネミーと区別
    unless actor
      members.size.times do
        break if members[@index].exist?
        @index += 1
      end
    end  
    @help_window.set_text(members[@index].name, 1)
    select_member(actor)
  end
  #--------------------------------------------------------------------------
  # ● ターゲット選択
  #--------------------------------------------------------------------------
  def select_member(actor = false)
    members = $game_party.members if actor
    members = $game_troop.members unless actor
    loop do
      update_basic
      @cursor_flame = 0 if @cursor_flame == 30
      @cursor.src_rect.set(0,  0, 32, 32) if @cursor_flame == 29
      @cursor.src_rect.set(0, 32, 32, 32) if @cursor_flame == 15
      point = @spriteset.set_cursor(actor, @index)
      @cursor.x = point[0]
      @cursor.y = point[1]
      @cursor_flame += 1
      if Input.trigger?(Input::B)
        Sound.play_cancel
        end_target_selection
        break
      elsif Input.trigger?(Input::C)
        Sound.play_decision
        @active_battler.action.target_index = @index
        end_target_selection
        end_skill_selection
        end_item_selection
        next_actor
        break
      end
      if Input.repeat?(Input::LEFT)
        if actor
          cursor_down(members, actor) if $back_attack
          cursor_up(members, actor) unless $back_attack
        else
          cursor_up(members, actor) if $back_attack
          cursor_down(members, actor) unless $back_attack
        end  
      end
      if Input.repeat?(Input::RIGHT)
        if actor
          cursor_up(members, actor) if $back_attack
          cursor_down(members, actor) unless $back_attack
        else
          cursor_down(members, actor) if $back_attack
          cursor_up(members, actor) unless $back_attack
        end
      end
      cursor_up(members, actor) if Input.repeat?(Input::UP)
      cursor_down(members, actor) if Input.repeat?(Input::DOWN)
    end
  end
  #--------------------------------------------------------------------------
  # ● カーソルを前に移動
  #--------------------------------------------------------------------------
  def cursor_up(members, actor)
    Sound.play_cursor
    members.size.times do
      @index += members.size - 1
      @index %= members.size
      break if actor
      break if members[@index].exist?
    end
    @help_window.set_text(members[@index].name, 1)
  end
  #--------------------------------------------------------------------------
  # ● カーソルを次に移動
  #--------------------------------------------------------------------------
  def cursor_down(members, actor)
    Sound.play_cursor
    members.size.times do
      @index += 1
      @index %= members.size
      break if actor
      break if members[@index].exist? && !actor
    end
    @help_window.set_text(members[@index].name, 1)
  end
  #--------------------------------------------------------------------------
  # ● ターゲット選択の終了
  #--------------------------------------------------------------------------
  def end_target_selection
    @actor_command_window.active = true if @actor_command_window.index == 0
    @skill_window.visible = true if @skill_window != nil
    @item_window.visible = true if @item_window != nil
    @cursor.dispose
    @cursor = nil
    if @actor_command_window.index == 0
      @help_window.dispose
      @help_window = nil
    end
  end
  #--------------------------------------------------------------------------
  # ● 逃走の処理  ※再定義
  #--------------------------------------------------------------------------
  def process_escape
    @info_viewport.visible = false
    @message_window.visible = true
    text = sprintf(Vocab::EscapeStart, $game_party.name)
    $game_message.texts.push(text)
    if $game_troop.preemptive
      success = true
    else
      success = (rand(100) < @escape_ratio)
    end
    Sound.play_escape
    # 動けないアクターを除いて逃走成功アクション
    if success
      for actor in $game_party.members
        unless actor.restriction == 4
          @spriteset.set_action(true, actor.index,actor.run_success)
        end
      end  
      wait_for_message
      battle_end(1)
    # 動けないアクターを除いて逃走失敗アクション
    else
      for actor in $game_party.members
        unless actor.restriction == 4
          @spriteset.set_action(true, actor.index,actor.run_ng)
        end
      end
      @escape_ratio += 10
      $game_message.texts.push('\.' + Vocab::EscapeFailure)
      wait_for_message
      $game_party.clear_actions
      start_main
    end
  end  
  #--------------------------------------------------------------------------
  # ● 勝利の処理
  #--------------------------------------------------------------------------
  alias process_victory_n01 process_victory
  def process_victory
    @status_window.visible = true
    @message_window.visible = false
    # ボスコラプスはウエイトを長く挟む
    for enemy in $game_troop.members
      break boss_wait = true if enemy.collapse_type == 3
    end
    wait(460) if boss_wait
    wait(N01::WIN_WAIT) unless boss_wait
    # 動けないアクターを除いて勝利アクション
    for actor in $game_party.members
      unless actor.restriction == 4
        @spriteset.set_action(true, actor.index,actor.win)
      end
    end
    process_victory_n01
  end
  #--------------------------------------------------------------------------
  # ● 戦闘処理の実行開始  ※再定義
  #--------------------------------------------------------------------------
  def start_main
    $game_troop.increase_turn
    @info_viewport.visible = true
    @info_viewport.ox = 0
    @party_command_window.active = false
    @actor_command_window.active = false
    @status_window.index = @actor_index = -1
    @active_battler = nil
    @message_window.clear
    $game_troop.make_actions
    make_action_orders
    # 情報表示ビューポートの移動
    move1_info_viewport
    # スキル名を表示するヘルプウインドウを作成
    @help_window = Window_Help.new
    @help_window.visible = false
    process_battle_event
  end
  #--------------------------------------------------------------------------
  # ● バトルイベントの処理
  #--------------------------------------------------------------------------
  alias process_battle_event_n01 process_battle_event
  def process_battle_event
    @message_window.visible = true
    @status_window.visible = false
    process_battle_event_n01
    @message_window.visible = false
    @status_window.visible = true
  end
  #--------------------------------------------------------------------------
  # ● 戦闘行動の実行
  #--------------------------------------------------------------------------
  alias execute_action_n01 execute_action
  def execute_action
    # スキル、アイテム拡張で行動前にフラッシュさせない設定があるなら
    if @active_battler.action.kind != 0
      obj = @active_battler.action.skill if @active_battler.action.kind == 1
      obj = @active_battler.action.item if @active_battler.action.kind == 2
      if obj.extension.include?("行動前フラッシュなし")
        @active_battler.white_flash = false
      end  
    end
    # バトラーをアクティブ化
    @active_battler.active = true
    execute_action_n01
  end
  #--------------------------------------------------------------------------
  # ● ターン終了  ※再定義
  #--------------------------------------------------------------------------
  def turn_end
    for member in $game_party.members + $game_troop.members
      next unless member.exist?
      member.clear_action_results
      member.slip_damage = false
      actor = member.actor?
      damage = 0
      # 0ターン解除のステートがあるかチェック
      for state in member.states
        member.remove_state(state.id) if state.extension.include?("0ターン解除")
        # スリップダメージ実行　state = [ 対象, 定数, 割合, 戦闘不能許可]
        if state.extension.include?("スリップダメージ")
          for ext in state.slip_extension
            if ext[0] == "hp"
              base_damage = ext[1] + member.maxhp * ext[2] / 100
              damage += base_damage + base_damage * (rand(5) - rand(5)) / 100
              slip_pop = ext[2]
              slip_dead = ext[3]
              slip_damage_flug = true
              member.slip_damage = true
            end
          end
        end  
      end
      # デフォルトのスリップダメージ
      if member.slip_damage? && member.exist? && !slip_damage_flug
        damage += member.apply_variance(member.maxhp / 10, 10)
        slip_dead = false
        slip_pop = true
        slip_damage_flug = true
        member.slip_damage = true
      end
      damage = member.hp - 1 if damage >= member.hp && slip_dead = false
      member.hp -= damage
      @spriteset.set_damage_pop(actor, member.index, damage) if slip_pop
      member.perform_collapse if member.dead? && member.slip_damage
    end
    @status_window.refresh
    # HPとMPのタイミングをずらす
    wait(55) if slip_damage_flug
    slip_damage_flug = false
    for member in $game_party.members + $game_troop.members
      next unless member.exist?
      member.clear_action_results
      actor = member.actor?
      mp_damage = 0
      for state in member.states
        if state.extension.include?("スリップダメージ") && member.hp > 0
          for ext in state.slip_extension
            if ext[0] == "mp"
              base_damage = ext[1] + member.maxmp * ext[2] / 100
              mp_damage += base_damage + base_damage * (rand(5) - rand(5)) / 100
              slip_pop = ext[2]
              slip_damage_flug = true
            end
          end
        end
        member.mp_damage = mp_damage
        member.mp -= mp_damage
        @spriteset.set_damage_pop(actor, member.index, mp_damage) if slip_pop
      end  
    end
    @status_window.refresh
    # ダメージと回復のタイミングをずらす
    wait(55) if slip_damage_flug
    # 自動回復があるか
    for member in $game_party.members
      member.clear_action_results
      if member.auto_hp_recover and !member.exist?
        plus_hp = member.maxhp / 20
        member.hp += plus_hp
        @spriteset.set_damage_pop(true, member.index, plus_hp * -1)
        plus_hp_flug = true
      end
    end
    @status_window.refresh
    wait(55) if plus_hp_flug
    @help_window.dispose if @help_window != nil
    @help_window = nil
    move2_info_viewport
    $game_troop.turn_ending = true
    $game_troop.preemptive = false
    $game_troop.surprise = false
    process_battle_event
    $game_troop.turn_ending = false
    start_party_command_selection
  end
  #--------------------------------------------------------------------------
  # ● 戦闘行動の実行 : 攻撃  ※再定義
  #--------------------------------------------------------------------------
  def execute_action_attack
    # 行動中に死なないようメンバー全員を不死身化
    immortaling
    target_decision
    self_index = @active_battler.index
    if @active_battler.actor?
      if @active_battler.weapon_id == 0
        action = @active_battler.non_weapon
      else  
        action = $data_weapons[@active_battler.weapon_id].base_action
      end  
    else
      if @active_battler.weapon == 0
        action = @active_battler.base_action
      else
        action = $data_weapons[@active_battler.weapon].base_action
      end  
    end
    @spriteset.set_action(@active_battler.actor?, self_index, action)
    playing_action
  end
  #--------------------------------------------------------------------------
  # ● 戦闘行動の実行 : 防御  ※再定義
  #--------------------------------------------------------------------------
  def execute_action_guard
    @help_window.set_text("防御", 1)
    @help_window.visible = true
    # バトラーのアクティブ化を解除
    @active_battler.active = false
    wait(45)
    @help_window.visible = false
  end
  #--------------------------------------------------------------------------
  # ● 戦闘行動の実行 : 逃走
  #--------------------------------------------------------------------------
  def execute_action_escape
    @spriteset.set_action(false, @active_battler.index, @active_battler.run_success)
    @help_window.set_text("逃走", 1)
    @help_window.visible = true
    # バトラーのアクティブ化を解除
    @active_battler.active = false
    @active_battler.escape
    Sound.play_escape
    wait(45)
    @help_window.visible = false
  end
  #--------------------------------------------------------------------------
  # ● 戦闘行動の実行 : 待機  ※再定義
  #--------------------------------------------------------------------------
  def execute_action_wait
    # バトラーのアクティブ化を解除
    @active_battler.active = false
    wait(45)
  end  
  #--------------------------------------------------------------------------
  # ● 戦闘行動の実行 : スキル  ※再定義
  #--------------------------------------------------------------------------
  def execute_action_skill
    # 行動中に死なないようメンバー全員を不死身化
    immortaling
    skill = @active_battler.action.skill
    target_decision(skill)
    @spriteset.set_action(@active_battler.actor?, @active_battler.index, skill.base_action)
    pop_help(skill)
    playing_action
    @active_battler.mp -= @active_battler.calc_mp_cost(skill)
    $game_temp.common_event_id = skill.common_event_id
  end
  #--------------------------------------------------------------------------
  # ● 戦闘行動の実行 : アイテム  ※再定義
  #--------------------------------------------------------------------------
  def execute_action_item
    # 行動中に死なないようメンバー全員を不死身化
    immortaling
    item = @active_battler.action.item
    target_decision(item)
    @spriteset.set_action(@active_battler.actor?, @active_battler.index, item.base_action)
    pop_help(item)
    playing_action
    $game_party.consume_item(item)
    $game_temp.common_event_id = item.common_event_id
  end
  #--------------------------------------------------------------------------
  # ● ターゲット決定
  #--------------------------------------------------------------------------
  def target_decision(obj = nil)
    @targets = @active_battler.action.make_targets
    # ターゲットがいない場合、アクション中断
    if @targets.size == 0
      action = @active_battler.recover_action
      @spriteset.set_action(@active_battler.actor?, @active_battler.index, action)
    end
    if obj != nil
      # デフォルトの複数回攻撃が設定されていれば単体ターゲットに変換
      if obj.for_two? or obj.for_three? or obj.dual?
        @targets = [@targets[0]]
      end
      # ランダムターゲットの場合、一体を選択しランダム範囲を保持
      if obj.extension.include?("ランダムターゲット")
        randum_targets = @targets.dup
        @targets = [randum_targets[rand(randum_targets.size)]]
      end
    end
    # ターゲット情報をバトラースプライトに送る
    @spriteset.set_target(@active_battler.actor?, @active_battler.index, @targets)
  end  
  #--------------------------------------------------------------------------
  # ● アクション実行中
  #--------------------------------------------------------------------------
  def playing_action
    loop do
      update_basic
      # アクティブバトラーに格納されているアクション情報を見る
      action = @active_battler.play
      next if action == 0
      @active_battler.play = 0
      if action[0] == "個別処理"
        individual
      elsif action == "コラプス許可"
        unimmortaling
      elsif action == "アクティブ解除"
        break active_end
      elsif action == "終了"
        break action_end
      elsif action[0] == "対象アニメ"
        damage_action(action[1])
      end
    end  
  end
  #--------------------------------------------------------------------------
  # ● 個別処理
  #--------------------------------------------------------------------------
  def individual
    # ターゲット情報を保持
    @individual_target = @targets
  end
  #--------------------------------------------------------------------------
  # ● コラプス禁止
  #--------------------------------------------------------------------------
  def immortaling
    # 全員に不死身付与
    for member in $game_party.members + $game_troop.members
      # 既に戦闘不能ならスキップ
      next if member.dead?
      # イベント等で不死身設定になっていたら解除を無効にするフラグを立てる
      member.non_dead = true if member.immortal
      member.immortal = true
    end  
  end  
  #--------------------------------------------------------------------------
  # ● コラプス許可
  #--------------------------------------------------------------------------
  def unimmortaling
    # 個別処理中はコラプス許可しない
    return if @active_battler.individual
    # 全員の不死身化解除(イベント等で不死身設定がされていれば除く)
    for member in $game_party.members + $game_troop.members
      next member.non_dead = false if member.non_dead
      next if member.dead?
      member.immortal = false
      member.add_state(1) if member.hp == 0
      member.perform_collapse
    end  
  end
  #--------------------------------------------------------------------------
  # ● アクティブ解除
  #--------------------------------------------------------------------------
  def active_end
    # 初期化
    @individual_target = nil
    @help_window.visible = false if @help_window.visible
    @active_battler.active = false
    # 念のため不死身化解除
    unimmortaling
    # 次の行動までウエイトを挟む
    wait(N01::ACTION_WAIT)
  end
  #--------------------------------------------------------------------------
  # ● アクション終了
  #--------------------------------------------------------------------------
  def action_end
    # スキル派生がある場合、行動続行
    if @active_battler.derivation != 0
      @active_battler.action.skill_id = @active_battler.derivation
      @active_battler.derivation = 0
      execute_action_skill
    end
    # 初期化
    @individual_target = nil
    @help_window.visible = false if @help_window.visible
    @active_battler.active = false
    # 念のため不死身化解除
    unimmortaling
    # 次の行動までウエイトを挟む
    wait(N01::ACTION_WAIT)
  end  
  #--------------------------------------------------------------------------
  # ● ダメージ処理
  #--------------------------------------------------------------------------
  def damage_action(action)
    # 個別処理の場合ターゲットを一つずつ抜き出す
    @targets = [@individual_target.shift] if @active_battler.individual
    # 行動の種類でアニメ先を分岐
    if @active_battler.action.skill?
      obj = skill = @active_battler.action.skill
      for target in @targets
        return if target == nil
        return if target.dead? && !obj.for_dead_friend?
        # HPが0なら戦闘不能復活以外はミスしない
        target.revival = true if obj.for_dead_friend?
        if target.hp == 0 && !obj.for_dead_friend?
          target.perfect_skill_effect(@active_battler, skill)
        else
          target.skill_effect(@active_battler, skill)
        end  
        pop_damage(target, skill, action)
        @spriteset.set_repeat_action(target.actor?, target.index)
      end
    elsif @active_battler.action.item?
      obj = item = @active_battler.action.item
      for target in @targets
        return if target == nil
        return if target.dead? && !obj.for_dead_friend?
        target.revival = true if obj.for_dead_friend?
        if target.hp == 0 && !obj.for_dead_friend?
          target.perfect_item_effect(@active_battler, item)
        else
          target.item_effect(@active_battler, item)
        end
        pop_damage(target, item, action)
        @spriteset.set_repeat_action(target.actor?, target.index)
      end
    else
      for target in @targets
        return if target == nil or target.dead?
        target.perfect_attack_effect(@active_battler) if target.hp <= 0
        target.attack_effect(@active_battler) unless target.hp <= 0
        pop_damage(target, nil, action)
        @spriteset.set_repeat_action(target.actor?, target.index)
      end
    end
    # ステータスウインドウをリフレッシュ
    @status_window.refresh
    # 連続行動中のランダムターゲットを考慮し、すぐに次のターゲットを選択
    return if obj == nil
    target_decision(obj) if obj.extension.include?("ランダムターゲット")
  end
  #--------------------------------------------------------------------------
  # ● ダメージ表示  action = [アニメID,反転フラグ,リアクション許可]
  #--------------------------------------------------------------------------
  def pop_damage(target, obj, action)
    index = @active_battler.index
    actor = @active_battler.actor?
    if obj != nil
      # スキルやアイテムが吸収属性なら
      if obj.absorb_damage
        @spriteset.set_damage_action(true, index, action) if actor
        @spriteset.set_damage_action(false, index, action) unless actor
      end
      # 拡張設定でダメージアクション禁止なら
      action[2] = false if obj.extension.include?("ダメージアクション禁止")
    end
    @spriteset.set_damage_action(false, target.index, action) unless target.actor?
    @spriteset.set_damage_action(true, target.index, action) if target.actor?
  end
end  
#==============================================================================
# ■ Game_BattleAction
#------------------------------------------------------------------------------
# 　戦闘行動を扱うクラスです。
#==============================================================================
class Game_BattleAction
  #--------------------------------------------------------------------------
  # ● ターゲットの配列作成  ※再定義
  #--------------------------------------------------------------------------
  def make_targets
    if attack?
      return make_attack_targets
    elsif skill?
      targets = make_obj_targets(skill)
      targets = make_obj_targets2(skill, targets) if skill.extension != ["なし"]
      return targets
    elsif item?
      targets = make_obj_targets(item)
      targets = make_obj_targets2(item, targets) if item.extension != ["なし"]
      return targets
    end
  end
  #--------------------------------------------------------------------------
  # ● スキルまたはアイテムのターゲット作成の拡張
  #--------------------------------------------------------------------------
  def make_obj_targets2(obj, targets)
    if obj.extension.include?("全域")
      targets = []
      targets += opponents_unit.existing_members
      targets += friends_unit.existing_members
    end
    if obj.extension.include?("自分以外")
      targets.delete($game_party.members[battler.index]) if battler.actor?
      targets.delete($game_troop.members[battler.index]) unless battler.actor?
    end
    return targets.compact
  end
end
#==============================================================================
# ■ Sprite_Base
#------------------------------------------------------------------------------
# 　アニメーションの表示処理を追加したスプライトのクラスです。
#==============================================================================
class Sprite_Base < Sprite
  #--------------------------------------------------------------------------
  # ● アニメーションの更新 アニメをスプライトに追従するように
  #--------------------------------------------------------------------------
  alias update_animation_n01 update_animation
  def update_animation
    @animation_ox = x - ox + width / 2
    @animation_oy = y - oy + height / 2
    update_animation_n01
  end
end  
#==============================================================================
# ■ Spriteset_Battle
#------------------------------------------------------------------------------
# 　バトル画面のスプライトをまとめたクラスです。
#==============================================================================
class Spriteset_Battle
  #--------------------------------------------------------------------------
  # ● エネミースプライトの作成
  #--------------------------------------------------------------------------
  def create_enemies
    @enemy_sprites = []
    for i in 0...$game_troop.members.size
      enemy = $game_troop.members[i]
      @enemy_sprites.push(Sprite_Battler.new(@viewport1, enemy))
      # バトル開始アクションを起こす
      @enemy_sprites[i].first_action if $game_troop.members[i] != nil
    end
  end
  #--------------------------------------------------------------------------
  # ● アクタースプライトの作成
  #--------------------------------------------------------------------------
  def create_actors
    @actor_sprites = []
    # メンバー最大数スプライトを用意
    member = N01::MAX_MEMBER
    for i in 0...member
      actor = $game_party.members[i]
      @actor_sprites.push(Sprite_Battler.new(@viewport1, actor))
      # バトル開始アクションを起こす
      @actor_sprites[i].first_action if $game_party.members[i] != nil
    end
  end
  #--------------------------------------------------------------------------
  # ● バトルフロアスプライトの作成
  #--------------------------------------------------------------------------
  def create_battlefloor
    @battlefloor_sprite = Sprite.new(@viewport1)
    @battlefloor_sprite.bitmap = Cache.system("BattleFloor")
    @battlefloor_sprite.x = N01::FLOOR[0]
    @battlefloor_sprite.y = N01::FLOOR[1]
    @battlefloor_sprite.z = N01::FLOOR[2]
    @battlefloor_sprite.opacity = 128
    # バックアタック時、フロアと背景を反転させる
    back_attack
    if $back_attack
      @battlefloor_sprite.mirror = true
      @battleback_sprite.mirror = true
      $game_troop.surprise = true
    else  
      $game_troop.surprise = false
    end  
  end  
  #--------------------------------------------------------------------------
  # ● バックアタック
  #--------------------------------------------------------------------------
  def back_attack  
    # 強制バックアタックならフラグオン
    for i in 0...N01::BACK_ATTACK_SWITCH.size
      return $back_attack = true if $game_switches[N01::BACK_ATTACK_SWITCH[i]]
    end
    # 不意打ちが発生していなければ処理を中断
    return $back_attack = false unless $game_troop.surprise && N01::BACK_ATTACK
    # 装備等によるバックアタック無効化をチェック
    for actor in $game_party.members
      return $back_attack = false if N01::NON_BACK_ATTACK_WEAPONS.include?(actor.weapon_id)
      return $back_attack = false if N01::NON_BACK_ATTACK_ARMOR1.include?(actor.armor1_id)
      return $back_attack = false if N01::NON_BACK_ATTACK_ARMOR2.include?(actor.armor2_id)
      return $back_attack = false if N01::NON_BACK_ATTACK_ARMOR3.include?(actor.armor3_id)
      return $back_attack = false if N01::NON_BACK_ATTACK_ARMOR4.include?(actor.armor4_id)
      for i in 0...N01::NON_BACK_ATTACK_SKILLS.size
        return $back_attack = false if actor.skill_id_learn?(N01::NON_BACK_ATTACK_SKILLS[i])
      end  
    end
    # バックアタック発生
    $back_attack = true
  end
  #--------------------------------------------------------------------------
  # ● アクタースプライトの更新  ※再定義
  #--------------------------------------------------------------------------
  def update_actors
    for i in 0...$game_party.members.size
      if @actor_sprites[i].battler.id != $game_party.members[i].id
        @actor_sprites[i].battler = $game_party.members[i]
        @actor_sprites[i].make_battler
        @actor_sprites[i].first_action
      end  
    end  
    for sprite in @actor_sprites
      sprite.update
    end
  end
  #--------------------------------------------------------------------------
  # ● ダメージアクションセット　
  #--------------------------------------------------------------------------  
  def set_damage_action(actor, index, action)
    @actor_sprites[index].damage_action(action) if actor
    @enemy_sprites[index].damage_action(action) unless actor
  end
  #--------------------------------------------------------------------------
  # ● ダメージPOPセット　
  #--------------------------------------------------------------------------  
  def set_damage_pop(actor, index, damage)
    @actor_sprites[index].damage_pop(damage) if actor
    @enemy_sprites[index].damage_pop(damage) unless actor
  end
  #--------------------------------------------------------------------------
  # ● ターゲットセット
  #--------------------------------------------------------------------------  
  def set_target(actor, index, target)
    @actor_sprites[index].get_target(target) if actor
    @enemy_sprites[index].get_target(target) unless actor
  end
  #--------------------------------------------------------------------------
  # ● アクションセット
  #--------------------------------------------------------------------------  
  def set_action(actor, index, kind)
    @actor_sprites[index].start_action(kind) if actor
    @enemy_sprites[index].start_action(kind) unless actor
  end  
  #--------------------------------------------------------------------------
  # ● 待機アクションセット
  #--------------------------------------------------------------------------  
  def set_repeat_action(actor, index)
    @actor_sprites[index].stand_by if actor
    @enemy_sprites[index].stand_by unless actor
  end
  #--------------------------------------------------------------------------
  # ● カーソル移動のセット
  #--------------------------------------------------------------------------  
  def set_cursor(actor, index)
    return [@actor_sprites[index].x, @actor_sprites[index].y] if actor
    return [@enemy_sprites[index].x, @enemy_sprites[index].y] unless actor
  end
end
#==============================================================================
# ■ Sprite_MoveAnime
#------------------------------------------------------------------------------
# 　アニメ飛ばし用のスプライトです。
#==============================================================================
class Sprite_MoveAnime < Sprite_Base
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :battler
  attr_accessor :base_x   # 自身の基本X座標
  attr_accessor :base_y   # 自身の基本Y座標
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(viewport,battler = nil)
    super(viewport)
    @battler = battler
    self.visible = false
    @base_x = 0
    @base_y = 0
    @move_x = 0                # 動かしたX座標
    @move_y = 0                # 動かしたY座標
    @moving_x = 0              # 1フレーム当たり動かすX座標
    @moving_y = 0              # 1フレーム当たり動かすY座標
    @orbit = 0                 # 円軌道
    @orbit_plus = 0            # 加算する円軌道
    @orbit_time = 0            # 円軌道計算時間
    @through = false           # 貫通するかどうか
    @finish = false            # 移動終了フラグ
    @time = 0                  # 移動時間
    @angle = 0                 # 武器の角度
    @angling = 0               # 1フレーム当たり動かす武器の角度
  end
  #--------------------------------------------------------------------------
  # ● アクションを取得
  #--------------------------------------------------------------------------  
  def anime_action(id,mirror,distanse_x,distanse_y,type,speed,orbit,weapon,icon_index,icon_weap
on)
    # 1フレームあたりの移動距離を算出
    @time = speed
    @moving_x = distanse_x / speed
    @moving_y = distanse_y / speed
    # 貫通するかどうか
    @through = true if type == 1
    # 円軌道を取得
    @orbit_plus = orbit
    @orbit_time = @time
    # 武器グラフィックの有無
    if weapon != ""
      action = N01::ANIME[weapon].dup
      @angle = action[0]
      end_angle = action[1]
      time = action[2]
      # 1フレームあたりの回転角度を出す
      @angling = (end_angle - @angle)/ time
      # 開始角度を取る
      self.angle = @angle
      # 武器グラフィックを表示
      self.mirror = mirror
      if icon_weapon
        self.bitmap = Cache.system("Iconset")
        self.src_rect.set(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
        self.ox = 12
        self.oy = 12
      else
        self.bitmap = Cache.character(icon_index)
        self.ox = self.bitmap.width / 2
        self.oy = self.bitmap.height / 2
      end  
      self.visible = true
      # バトラーより手前に表示
      self.z = 1000
    end  
    # 最初は動かさず一回だけ表示
    self.x = @base_x + @move_x
    self.y = @base_y + @move_y + @orbit
    if id != 0
      animation = $data_animations[id]
      start_animation(animation, mirror)
    end
  end  
  #--------------------------------------------------------------------------
  # ● 変化した動きをリセット
  #--------------------------------------------------------------------------  
  def action_reset
    @moving_x = @moving_y = @move_x = @move_y = @base_x = @base_y = @orbit = 0
    @orbit_time = @angling = @angle = 0    
    @through = self.visible = @finish = false
    dispose_animation
  end  
  #--------------------------------------------------------------------------
  # ● 貫通終了
  #--------------------------------------------------------------------------  
  def finish?
    return @finish
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
    super
    # 時間消費
    @time -= 1
    # 時間まで指定の動きを
    if @time >= 0
      @move_x += @moving_x
      @move_y += @moving_y
      # 円軌道計算
      if @time < @orbit_time / 2
        @orbit_plus = @orbit_plus * 5 / 4
      elsif @time == @orbit_time / 2
        @orbit_plus *= -1
      else
        @orbit_plus = @orbit_plus * 2 / 3
      end  
      @orbit += @orbit_plus
    end    
    # 時間がきても貫通ならそのまま直進
    @time = 100 if @time < 0 && @through
    @finish = true if @time < 0 && !@through
    # スプライトの座標を更新
    self.x = @base_x + @move_x
    self.y = @base_y + @move_y + @orbit
    # 貫通の場合、画面から消えたら終了フラグオン
    if self.x < -200 or self.x > 840 or self.y < -200 or self.y > 680
      @finish = true
    end
    # 武器グラフィック更新
    if self.visible
      @angle += @angling
      self.angle = @angle
    end  
  end
end
#==============================================================================
# ■ Sprite_Weapon
#------------------------------------------------------------------------------
# 　ウエポン表示用のスプライトです。
#==============================================================================
class Sprite_Weapon < Sprite_Base
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :battler
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(viewport,battler = nil)
    super(viewport)
    @battler = battler
    @action = []                     # 武器のアクション情報
    @move_x = 0                      # 動かしたX座標
    @move_y = 0                      # 動かしたY座標
    @move_z = 0                      # 動かしたZ座標
    @plus_x = 0                      # 微調整分のX座標
    @plus_y = 0                      # 微調整分のY座標
    @angle = 0                       # 武器の回転角度
    @zoom_x = 1                      # 武器の横拡大率
    @zoom_y = 1                      # 武器の縦拡大率
    @moving_x = 0                    # 1フレーム当たり動かすX座標
    @moving_y = 0                    # 1フレーム当たり動かすY座標
    @angling = 0                     # 1フレーム当たりの回転角度
    @zooming_x = 1                   # 1フレーム当たりの横拡大率
    @zooming_y = 1                   # 1フレーム当たりの縦拡大率    
    @mirroring = false               # バトラーが反転しているか
    @time = N01::ANIME_PATTERN + 1   # 更新回数
    # 武器を取得
    weapon_graphics
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  def dispose
    self.bitmap.dispose if self.bitmap != nil
    super
  end
  #--------------------------------------------------------------------------
  # ● 武器を取得
  #--------------------------------------------------------------------------  
  def weapon_graphics(left = false)
    if @battler.actor?
      weapon = @battler.weapons[0] unless left
      weapon = @battler.weapons[1] if left
    else
      weapon = $data_weapons[@battler.weapon]
      # エネミー反転フラグ確認
      @mirroring = true if @battler.action_mirror
    end
    # 武器がなければ処理をキャンセル
    return if weapon == nil
    # アイコンを利用するなら
    if weapon.graphic == ""
      icon_index = weapon.icon_index
      self.bitmap = Cache.system("Iconset")
      self.src_rect.set(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
      @weapon_width = @weapon_height = 24
    # ID指定があったら、アイコンではなくそのグラフィックを取得  
    else
      self.bitmap = Cache.character(weapon.graphic)
      @weapon_width = self.bitmap.width
      @weapon_height = self.bitmap.height
    end
  end
  #--------------------------------------------------------------------------
  # ● 武器アクションを取得
  #--------------------------------------------------------------------------  
  def weapon_action(action,loop)
    # 名称がない場合は非表示に
    if action == ""
      self.visible = false
    # 素手なら非表示に
    elsif @weapon_id == 0
      self.visible = false
    # 武器アクション情報を受け取る
    else
      @action = N01::ANIME[action]
      act0 = @action[0]
      act1 = @action[1]
      act2 = @action[2]
      act3 = @action[3]
      act4 = @action[4]
      act5 = @action[5]
      act6 = @action[6]
      act7 = @action[7]
      act8 = @action[8]
      act9 = @action[9]
      act10 = @action[10]
      # バトラーが反転してる場合、X軸の動きを逆に
      if @mirroring
        act0 *= -1
        act3 *= -1
        act4 *= -1
        act9 *= -1
      end
      # バックアタック時には逆に
      if $back_attack && N01::BACK_ATTACK
        act0 *= -1
        act3 *= -1
        act4 *= -1
        act9 *= -1
      end
      # キャラのアニメパターン数をチェック
      time = N01::ANIME_PATTERN
      # Z座標をチェック
      if act2
        self.z = @battler.position_z + 1
      else
        self.z = @battler.position_z - 1
      end
      # 反転はここで実行し、すでに反転している場合は元に戻す
      if act6
        if self.mirror
          self.mirror = false
        else
          self.mirror = true
        end
      end
      # バトラーの反転を反映
      if @mirroring
        if self.mirror
          self.mirror = false
        else
          self.mirror = true
        end
      end
      # バックアタック時には逆に
      if $back_attack && N01::BACK_ATTACK
        if self.mirror
          self.mirror = false
        else
          self.mirror = true
        end
      end  
      # アニメパターン数で割った変化を計算
      @moving_x = act0 / time
      @moving_y = act1 / time
      # 最初の角度を代入
      @angle = act3
      self.angle = @angle
      # 更新角度を計算
      @angling = (act4 - act3)/ time
      # 角度が割り切れない場合、ここで余り分を回転加算
      @angle += (act4 - act3) % time
      # 拡大縮小
      @zooming_x = (1 - act7) / time
      @zooming_y = (1 - act8) / time
      # 反転してる場合、回転元の原点を逆に
      if self.mirror
        case act5
        when 1 # 左上→右上に
          act5 = 2
        when 2 # 右上→左上に
          act5 = 1
        when 3 # 左下→右下に
          act5 = 4
        when 4 # 右下→左下に
          act5 = 3
        end  
      end    
      # 回転元の原点を設定
      case act5
      when 0 # 中心
        self.ox = @weapon_width / 2
        self.oy = @weapon_height / 2
      when 1 # 左上
        self.ox = 0
        self.oy = 0
      when 2 # 右上
        self.ox = @weapon_width
        self.oy = 0
      when 3 # 左下
        self.ox = 0
        self.oy = @weapon_height
      when 4 # 右下
        self.ox = @weapon_width
        self.oy = @weapon_height
      end  
      # 座標微調整
      @plus_x = act9
      @plus_y = act10
      # 往復ループならフラグオン
      @loop = true if loop == 0
      # 初回で0から始まるように、この時点で-1回の動きをさせる
      @angle -= @angling
      @zoom_x -= @zooming_x
      @zoom_y -= @zooming_y
      # スプライトの座標を更新
      @move_x -= @moving_x
      @move_y -= @moving_y
      @move_z = 1000 if act2
      # 可視
      self.visible = true
    end
  end  
  #--------------------------------------------------------------------------
  # ● 変化した動きを全部リセット
  #--------------------------------------------------------------------------  
  def action_reset
    @moving_x = @moving_y = @move_x = @move_y = @plus_x = @plus_y = 0
    @angling = @zooming_x = @zooming_y = @angle = self.angle = @move_z = 0
    @zoom_x = @zoom_y = self.zoom_x = self.zoom_y = 1
    self.mirror = self.visible = @loop = false
    @action = []
    @time = N01::ANIME_PATTERN + 1
  end
  #--------------------------------------------------------------------------
  # ● 往復ループさせる
  #--------------------------------------------------------------------------  
  def action_loop
    # 動きを反対に
    @angling *= -1
    @zooming_x *= -1
    @zooming_y *= -1
    @moving_x *= -1
    @moving_y *= -1
  end  
  #--------------------------------------------------------------------------
  # ● アクターが反転している場合、自身も反転させる
  #--------------------------------------------------------------------------
  def mirroring
    return @mirroring = false if @mirroring
    @mirroring = true
  end  
  #--------------------------------------------------------------------------
  # ● アクターアニメが更新された時のみ武器アクションの変化を更新
  #--------------------------------------------------------------------------
  def action
    return if @time <= 0
    @time -= 1
    # 回転、拡大縮小を更新
    @angle += @angling
    @zoom_x += @zooming_x
    @zoom_y += @zooming_y
    # スプライトの座標を更新
    @move_x += @moving_x
    @move_y += @moving_y
    # 往復ループなら動きを反転
    if @loop && @time == 0
      @time = N01::ANIME_PATTERN + 1
      action_loop
    end
  end  
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
    super
    # 回転、拡大縮小を更新
    self.angle = @angle
    self.zoom_x = @zoom_x
    self.zoom_y = @zoom_y
    # スプライトの座標を更新
    self.x = @battler.position_x + @move_x + @plus_x
    self.y = @battler.position_y + @move_y + @plus_y
    self.z = @battler.position_z + @move_z - 1
  end
end

#==============================================================================
# ■ Game_Battler (分割定義 1)
#------------------------------------------------------------------------------
# 　バトラーを扱うクラスです。
#==============================================================================
class Game_Battler
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :mp_damage        # 行動結果: MP ダメージ
  attr_accessor :move_x           # X方向の移動補正
  attr_accessor :move_y           # Y方向の移動補正
  attr_accessor :move_z           # Z方向の移動補正
  attr_accessor :jump             # ジャンプ補正
  attr_accessor :active           # アクティブか
  attr_accessor :non_dead         # 不死身フラグ
  attr_accessor :slip_damage      # スリップダメージフラグ
  attr_accessor :derivation       # スキル派生ID
  attr_accessor :individual       # スキル派生ID
  attr_accessor :play             # アクション情報
  attr_accessor :force_action     # 強制されるアクション情報
  attr_accessor :force_target     # ターゲット変更情報
  attr_accessor :revival          # 復活
  attr_reader   :base_position_x  # 初期配置X座標
  attr_reader   :base_position_y  # 初期配置Y座標  
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  alias initialize_n01 initialize
  def initialize
    initialize_n01
    @move_x = @move_y = @move_z = @plus_y = @jump = @derivation = @play = 0
    @force_action = @force_target = @base_position_x = @base_position_y = 0
    @active = @non_dead = @individual = @slip_damage = @revival = false
  end
  #--------------------------------------------------------------------------
  # ● 一番新しいステートIDを返す
  #--------------------------------------------------------------------------
  def state_id
    return @states[@states.size - 1]
  end
  #--------------------------------------------------------------------------
  # ● 通常攻撃によるダメージ計算  二刀流補正
  #--------------------------------------------------------------------------
  alias make_attack_damage_value_n01 make_attack_damage_value
  def make_attack_damage_value(attacker)
    make_attack_damage_value_n01(attacker)
    # 二本の武器を装備しているときのみ補正を有効に
    return unless attacker.actor?
    return if attacker.weapons[0] == nil
    return if attacker.weapons[1] == nil
    @hp_damage = @hp_damage * N01::TWO_SWORDS_STYLE[0] / 100
  end
  #--------------------------------------------------------------------------
  # ● スキルまたはアイテムによるダメージ計算　二刀流補正
  #--------------------------------------------------------------------------
  alias make_obj_damage_value_n01 make_obj_damage_value
  def make_obj_damage_value(user, obj)
    make_obj_damage_value_n01(user, obj)
    # 二本の武器を装備しているときのみ補正を有効に
    return unless user.actor?
    return if user.weapons[0] == nil
    return if user.weapons[1] == nil
    if obj.damage_to_mp  
      @mp_damage = @mp_damage * N01::TWO_SWORDS_STYLE[1] / 100 # MP にダメージ
    else
      @hp_damage = @hp_damage * N01::TWO_SWORDS_STYLE[1] / 100 # HP にダメージ
    end
  end
  #--------------------------------------------------------------------------
  # ● 通常攻撃の効果適用  すでに戦闘不能で絶対に回避できない処理
  #--------------------------------------------------------------------------
  def perfect_attack_effect(attacker)
    clear_action_results
    make_attack_damage_value(attacker)            # ダメージ計算
    execute_damage(attacker)                      # ダメージ反映
    apply_state_changes(attacker)                 # ステート変化
  end
  #--------------------------------------------------------------------------
  # ● スキルの効果適用  すでに戦闘不能で絶対に回避できない処理
  #--------------------------------------------------------------------------
  def perfect_skill_effect(user, skill)
    clear_action_results
    make_obj_damage_value(user, skill)            # ダメージ計算
    make_obj_absorb_effect(user, skill)           # 吸収効果計算
    execute_damage(user)                          # ダメージ反映
    apply_state_changes(skill)                    # ステート変化
  end
  #--------------------------------------------------------------------------
  # ● アイテムの効果適用  すでに戦闘不能で絶対に回避できない処理
  #--------------------------------------------------------------------------
  def perfect_item_effect(user, item)
    clear_action_results
    hp_recovery = calc_hp_recovery(user, item)    # HP 回復量計算
    mp_recovery = calc_mp_recovery(user, item)    # MP 回復量計算
    make_obj_damage_value(user, item)             # ダメージ計算
    @hp_damage -= hp_recovery                     # HP 回復量を差し引く
    @mp_damage -= mp_recovery                     # MP 回復量を差し引く
    make_obj_absorb_effect(user, item)            # 吸収効果計算
    execute_damage(user)                          # ダメージ反映
    item_growth_effect(user, item)                # 成長効果適用
    if item.physical_attack and @hp_damage == 0   # 物理ノーダメージ判定
      return                                    
    end
    apply_state_changes(item)                     # ステート変化
  end
  #--------------------------------------------------------------------------
  # ● 初期配置の変更
  #--------------------------------------------------------------------------
  def change_base_position(x, y)
    @base_position_x = x
    @base_position_y = y
  end
  #--------------------------------------------------------------------------
  # ● 初期化
  #--------------------------------------------------------------------------
  def reset_coordinate
    @move_x = @move_y = @move_z = @jump = @derivation = 0
    @active = @non_dead = @individual = false    
  end
  #--------------------------------------------------------------------------
  # ● スリップダメージの効果適用
  #--------------------------------------------------------------------------
  def slip_damage_effect
    if slip_damage? and @hp > 0
      @hp_damage = apply_variance(maxhp / 10, 10)
      @hp_damage = @hp - 1 if @hp_damage >= @hp
      self.hp -= @hp_damage
    end
  end
end  
#==============================================================================
# ■ Game_Actor
#------------------------------------------------------------------------------
# 　アクターを扱うクラスです。
#==============================================================================
class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :two_swords_change          # 二刀流強制持ち替えフラグ
  #--------------------------------------------------------------------------
  # ● IDによるスキルの習得済み判定
  #--------------------------------------------------------------------------
  def skill_id_learn?(skill_id)
    return @skills.include?(skill_id)
  end
  #--------------------------------------------------------------------------
  # ● グラフィックの変更
  #--------------------------------------------------------------------------
  def graphic_change(character_name)
    @character_name = character_name
  end
  #--------------------------------------------------------------------------
  # ● コラプスの実行 ※再定義
  #--------------------------------------------------------------------------
  def perform_collapse
    Sound.play_actor_collapse if $game_temp.in_battle and dead?
  end
  #--------------------------------------------------------------------------
  # ● 初期配置の取得
  #--------------------------------------------------------------------------
  def base_position
    base = N01::ACTOR_POSITION[self.index]
    @base_position_x = base[0]
    @base_position_y = base[1]
    # バックアタック時はX軸を逆に
    @base_position_x = N01::GAME_SCREEN[0] - base[0] if $back_attack && N01::BACK_ATTACK
  end
  #--------------------------------------------------------------------------
  # ● バトル画面 X 座標の取得
  #--------------------------------------------------------------------------
  def position_x
    return 0 if self.index == nil
    return @base_position_x + @move_x
  end
  #--------------------------------------------------------------------------
  # ● バトル画面 Y 座標の取得
  #--------------------------------------------------------------------------
  def position_y
    return 0 if self.index == nil
    return @base_position_y + @move_y + @jump
  end
  #--------------------------------------------------------------------------
  # ● バトル画面 Z 座標の取得
  #--------------------------------------------------------------------------
  def position_z
    return 0 if self.index == nil
    return self.index + @base_position_y + @move_y + @move_z - @jump + 200
  end  
end
#==============================================================================
# ■ Game_Enemy
#------------------------------------------------------------------------------
# 　エネミーを扱うクラスです。
#==============================================================================
class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  # ● コラプスの実行 ※再定義
  #--------------------------------------------------------------------------
  def perform_collapse
    @force_action = ["N01collapse"] if $game_temp.in_battle and dead?
  end
  #--------------------------------------------------------------------------
  # ● 初期配置の取得
  #--------------------------------------------------------------------------
  def base_position
    return if self.index == nil
    # バトラー画像のサイズをチェックしY座標を修正
    bitmap = Bitmap.new("Graphics/Battlers/" + @battler_name) if !self.anime_on
    bitmap = Bitmap.new("Graphics/Characters/" + @battler_name) if self.anime_on && N01::WALK_ANIME
    bitmap = Bitmap.new("Graphics/Characters/" + @battler_name + "_1") if self.anime_on && !N01::WALK_ANIME
    height = bitmap.height
    @base_position_x = self.screen_x + self.position_plus[0]
    @base_position_y = self.screen_y + self.position_plus[1] - height / 3
    bitmap.dispose
    # バックアタック時はX軸を逆に
    if $back_attack && N01::BACK_ATTACK
      @base_position_x = N01::GAME_SCREEN[0] - self.screen_x - self.position_plus[0]
    end
  end
  #--------------------------------------------------------------------------
  # ● バトル画面 X 座標の取得
  #--------------------------------------------------------------------------
  def position_x
    return @base_position_x - @move_x
  end
  #--------------------------------------------------------------------------
  # ● バトル画面 Y 座標の取得
  #--------------------------------------------------------------------------
  def position_y
    return @base_position_y + @move_y + @jump
  end
  #--------------------------------------------------------------------------
  # ● バトル画面 Z 座標の取得
  #--------------------------------------------------------------------------
  def position_z
    return position_y + @move_z - @jump + 200
  end
end
#==============================================================================
# ■ Sprite_Damage
#------------------------------------------------------------------------------
# 　ダメージ表示のスプライトです。
#==============================================================================
class Sprite_Damage < Sprite_Base
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :battler
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(viewport,battler = nil)
    super(viewport)
    @battler = battler
    @damage = 0
    @duration = 0
    @x = 0
    @y = 0
    @z_plus = 0
    @minus = false
    @num1 = Sprite.new(viewport)
    @num2 = Sprite.new(viewport)
    @num3 = Sprite.new(viewport)
    @num4 = Sprite.new(viewport)
    @num5 = Sprite.new(viewport)
    @num1.visible = false
    @num2.visible = false
    @num3.visible = false
    @num4.visible = false
    @num5.visible = false
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
    move_damage(@num5, @pop_time) if @num5.visible
    move_damage(@num4, @pop_time - 2) if @num4.visible
    move_damage(@num3, @pop_time - 4) if @num3.visible
    move_damage(@num2, @pop_time - 6) if @num2.visible
    move_damage(@num1, @pop_time - 8) if @num1.visible
    move_window if @window != nil
    @duration -= 1 if @duration > 0
  end
  #--------------------------------------------------------------------------
  # ● 数値の動き
  #--------------------------------------------------------------------------
  def move_damage(num, min)
    case @duration
    when min-1..min
      num.y -= 4
    when min-3..min-2
      num.y -= 3
    when min-6..min-4
      num.y -= 2
    when min-14..min-7
      num.y += 2
    when min-17..min-15
      num.y -= 2
    when min-23..min-18
      num.y += 1
    when min-27..min-24
      num.y -= 1
    when min-30..min-28
      num.y += 1
    when min-33..min-31
      num.y -= 1
    when min-36..min-34
      num.y += 1
    end
    num.opacity = 256 - (12 - @duration) * 32
    num.visible = false if @duration == 0
  end
  #--------------------------------------------------------------------------
  # ● 文字ウインドウの動き
  #--------------------------------------------------------------------------
  def move_window
    @window.x -= 6 if @window_time > 0 && @window.x > 0
    @window_time -= 1
    if @duration == 0
      @window.dispose
      @window = nil
    end
  end  
  #--------------------------------------------------------------------------
  # ● ダメージPOP準備
  #--------------------------------------------------------------------------
  def damage_pop(num = nil)
    reset
    damage = battler.hp_damage
    # ステートの変化を抜き出す
    states = battler.added_states
    text = ""
    # MPダメージ用テキスト
    if @battler.mp_damage != 0
      text = N01::POP_MP_DAM if battler.mp_damage > 0
      text = N01::POP_MP_REC if battler.mp_damage < 0
      damage = battler.mp_damage
    end
    # スリップダメージはMPダメージ以外文字を表示させない
    if num == nil
      text = N01::POP_MISS if battler.missed && states == []
      text = N01::POP_DAMAGE0 if damage == 0 && states == [] && !battler.revival
      text = N01::POP_EVA if battler.evaded
      text = N01::POP_CRI if battler.critical
      for state in states
        # POPなし設定のステートは表示させない
        unless $data_states[state.id].extension.include?("POPなし")
          text += " " if text != ""
          text += state.name
        end
      end
    else
      damage = num
    end
    # ダメージと回復を分ける
    @minus = false
    @minus = true if damage < 0
    damage = damage.abs
    @x = battler.position_x
    @y = battler.position_y
    window(text) if text != ""
    @pop_time = N01::NUM_DURATION
    # ダメージがなければ数字のPOPをさせない
    return @duration = @pop_time if damage == 0
    @num_time = -1
    damage_file(@num1, damage % 10, @pop_time - 7) if damage >= 0
    damage_file(@num2, (damage % 100)/10, @pop_time - 5) if damage >= 10
    damage_file(@num3, (damage % 1000)/100, @pop_time - 3) if damage >= 100
    damage_file(@num4, (damage % 10000)/1000, @pop_time - 1) if damage >= 1000
    damage_file(@num5, (damage % 100000)/10000, @pop_time + 1) if damage >= 10000
  end  
  #--------------------------------------------------------------------------
  # ● 情報ウインドウ準備
  #--------------------------------------------------------------------------
  def window(text)
    @window = Window_Damage.new(@x - 64, @y - 22)
    @window.pop_text(text)
    @window_time = 5
  end  
  #--------------------------------------------------------------------------
  # ● 数字画像準備
  #--------------------------------------------------------------------------
  def damage_file(num, cw, dur)
    num.visible = true
    # ファイル判別
    file = N01::DAMAGE_GRAPHICS
    file = N01::RECOVER_GRAPHICS if @minus
    # 数字
    num.bitmap = Cache.system(file)
    @num_time += 1
    sx = num.bitmap.width / 10
    num.src_rect.set(cw * sx, 0, sx, num.height)
    num.x = @x - (num.width + N01::NUM_INTERBAL) * @num_time
    num.y = @y
    num.z = 2000 - @num_time
    @duration = dur
    @window.x = num.x - @window.width + 64 if @window != nil && N01::NON_DAMAGE_WINDOW
    @window.x = num.x - @window.width + 26 if @window != nil && !N01::NON_DAMAGE_WINDOW
    @window.x = 0 if @window != nil && @window.x < 0
  end
  #--------------------------------------------------------------------------
  # ● ダメージリセット
  #--------------------------------------------------------------------------
  def reset
    @num5.visible = @num4.visible = @num3.visible = @num2.visible = @num1.visible = false
    @window.dispose if @window != nil
    @window = nil
  end  
  #--------------------------------------------------------------------------
  # ● 開放
  #--------------------------------------------------------------------------
  def dispose
    super
    @num1.dispose
    @num2.dispose
    @num3.dispose
    @num4.dispose
    @num5.dispose
    @window.dispose if @window != nil
  end  
end
#==============================================================================
# ■ Window_Damage
#------------------------------------------------------------------------------
# 　クリティカル等を表示するウインドウです。
#==============================================================================
class Window_Damage < Window_Base
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(x, y)
    super(x, y, 160, 46)
    self.opacity = 0 if N01::NON_DAMAGE_WINDOW
  end
  #--------------------------------------------------------------------------
  # ● ウィンドウ内容の作成
  #--------------------------------------------------------------------------
  def create_contents
    self.contents.dispose
    self.contents = Bitmap.new(width - 32, height - 32)
  end
  #--------------------------------------------------------------------------
  # ● テキスト設定
  #--------------------------------------------------------------------------
  def pop_text(text, align = 1)
    self.contents.clear
    self.width = self.contents.text_size(text).width + 36
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.color = normal_color
    self.contents.font.size = 16
    self.contents.draw_text(0,-8, width - 32, 32, text, align)
  end  
end  
#==============================================================================
# ■ Window_Base
#------------------------------------------------------------------------------
# 　ゲーム中のすべてのウィンドウのスーパークラスです。
#==============================================================================
class Window_Base < Window  
  #--------------------------------------------------------------------------
  # ● ステートの描画  ※再定義(ステートアイコンを表示しない設定を反映)
  #--------------------------------------------------------------------------
  def draw_actor_state(actor, x, y, width = 96)
    count = 0
    for state in actor.states
      break if state.extension.include?("アイコン非表示")
      draw_icon(state.icon_index, x + 24 * count, y)
      count += 1
      break if (24 * count > width - 24)
    end
  end
end

!-Or you can just have a look on that page and download this file (we're up to the version 2.3!) .

!-Have a look on version 1.7 translated by WolfwoodSama! Click here.

!-Don't forget to visit the site anyway - RPG Tankentai (I guess I'm done with credits ^^ )
There are interesting RGSS/RGSS2 scripts.

This post has been edited by TheJoan: Mar 4 2008, 10:16 AM

[jasonicus]

Nice script, but this needs to be translated so we can know exactly what to setup. Unless there is nothing?

[InfiniteSpawn]

I agree, it should be translated. Got an error with the demo though immediately after pressing new game...

[Jokuer]

can you use a better explanation cause I dont get it and everytime I start the demo it crashes

[Elemental Crisis]

I might translate this if I have time. I'm not making any promises though.

[darkkyros]

I agree, it should be translated. Got an error with the demo though immediately after pressing new game...

If the graphic for the main characters are blank then change then to the ones that came with the demo. Then on the map the NPC, on the far lower-left, needs a graphic (doesn't matter what one). And then you should be able to play it.

This goes great with the battleback script. Here's a pic of it combined with the battleback (I made my own battleback with a 17x13 map).



This post has been edited by darkkyros: Jan 22 2008, 10:44 PM

[TheJoan]

Hello:
For the ones who encounter bug reports, check in the map and in the database and replace the characters from the project folder. I forgot to mention it, my bad. (The character in the map is the priest but it doesn't really matter...)

The only things to setup are in one hand sprites in this seize: 96*128 and named "$xxxx.png".

Example:


$Ralph.png

Then you have just to set this file as the hero graphics:


And, obviously, to put the 3 scripts before Main.

For any other problems, please send a screenshot with your post.

darkkyros:

Indeed, it suits very well with this script! ^¸^

This post has been edited by TheJoan: Jan 23 2008, 12:33 AM

[Zedna]

This script is great! I love it! Also had the problems at first but thanks to TheJoan who pretty much cleared up what to do, it is working now! Great Side-View Battle script! I will maybe use this for my game too! ^^

Edit: It would be cool if anybody were to translate this if anybody has time please!

This post has been edited by Zedna: Jan 23 2008, 02:15 AM

[hpwong87]

Does this script fix the error that the other sideview-battle script had? The one where when you enter a battle with one or more of your ally dead the game would get an error. Do we fix that by creating another charaset of the actors lying dead and put that into the scripts. If so can someone please do that because I am an absolutely noob when it comes to programming.

[TheJoan]

You can go on, the script works perfectly in any case! ^¸^
I had a doubt about this situation but after testing once more, I can affirm it doesn't get these errors.

[darkkyros]

Does this script fix the error that the other sideview-battle script had? The one where when you enter a battle with one or more of your ally dead the game would get an error. Do we fix that by creating another charaset of the actors lying dead and put that into the scripts. If so can someone please do that because I am an absolutely noob when it comes to programming.

Just as he said, you don't get any errors. And, you don't need to worry about downsets of the characters either. It automatically makes the down graphic.

[jasonicus]

I get this error when the enemy attacks the hero party:



It pertains to the line - path = folder_name + filename

WTF?

I even tried this in a new project and got the same error, so it is nothing to do with other scripts. I don't get it, what could be wrong?

This post has been edited by jasonicus: Jan 24 2008, 03:25 PM

[bluntsword]

....eh?

[jasonicus]

I think my issue is that it cannot load the damage bitmaps properly. It works fine in the demo, but not in a new project.

Bluntsword, did you place the graphics files from the demo into a folder? There are specific files needed to run.

[darkkyros]

....eh?

Grab the character graphics from the demo.

@jasonicus - I had the same problem before. But, I can't remember how I fixed it. I uploaded the scripts.vxdata for you. I also added the animations.vxdata. When the character or enemy attacks, if it seems they wait too long before returning, then copy the animations.vxdata over yours.

Attached File(s)

 Scripts__Animations.zip ( 184.81K ) Number of downloads: 249

 

[sorcer loko]

Please, can I do a topic on a brazilian forum, with this RGSS2 Script?
Please.

[jasonicus]

....eh?

Grab the character graphics from the demo.

@jasonicus - I had the same problem before. But, I can't remember how I fixed it. I uploaded the scripts.vxdata for you. I also added the animations.vxdata. When the character or enemy attacks, if it seems they wait too long before returning, then copy the animations.vxdata over yours.

I'll give this a shot, thanks.

[darkkyros]

I'll give this a shot, thanks.

No problem. Let me know if that fixes it for you.

[jasonicus]

Seems to have worked. Thats crazy but cool. Thanks a lot! Now, I just have to re-setup the other things I had already added but that not much yet.

[darkkyros]

Seems to have worked. Thats crazy but cool. Thanks a lot! Now, I just have to re-setup the other things I had already added but that not much yet.

Not a problem. I'm glad it worked.

EDIT: does any one know if you set an enemy up to use a character set in battle instead of a battler graphic. The "Evil" Charactersets for instance.

This post has been edited by darkkyros: Jan 24 2008, 05:08 PM