全动画战斗脚本下如何改角色图形

遠夜 · 发表于 2009-2-13 07:05:41

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

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

x

我采用的是全动画战斗脚本,
求教如何在角色战斗不能情况下不显示角色图形或者显示我指定的角色死亡图形,完全看不明白该在哪里修改,泪......
脚本一共是3个,全部如下:
第一个脚本名字:サイドビュー設定

晕,脚本贴不下,偶分开放= =

#==============================================================================
# ■ module N01 Ver2.6
#------------------------------------------------------------------------------
# 　サイドビューバトルのカスタマイズ項目です。
#==============================================================================
module N01
#--------------------------------------------------------------------------
# ● セッティング
#--------------------------------------------------------------------------
# アクター初期位置　一人目二人目三人目四人目
# X軸 Y軸 X軸 Y軸 X軸 Y軸 X軸 Y軸
ACTOR_POSITION = [[515,170],[530,210],[545,250],[560,290]]
# 戦闘メンバー最大数(多人数パーティスクリプト等で増えた時専用)
# 上の初期位置も人数分増やしてください
MAX_MEMBER = 4
# 戦闘コマンドのウインドウ位置微調整 COMMAND_POSITION = [X軸,Y軸]
COMMAND_POSITION = [ -208, -116]
# バックアタック時の戦闘コマンドのウインドウ位置微調整
COMMAND_POSITION_BACKATTACK = [ 48, -116]
# アクターカーソル位置微調整 ACTOR_CURSOR = [X軸,Y軸]
ACTOR_CURSOR = [ 0, 48]
# エネミーカーソル位置微調整 ENEMY_CURSOR = [X軸,Y軸]
ENEMY_CURSOR = [ 0, 32]
# 戦闘で行動終了後、次のバトラーが行動開始するまでに挟むウエイト時間
ACTION_WAIT = 2
# エネミーのコラプス(撃破時の退場)前に挟むウエイト時間
COLLAPSE_WAIT = 6
# 勝利前に挟むウエイト時間
WIN_WAIT = 10
# アクターが武器なしで攻撃した場合のヒットアニメID(エネミーはデータベースの設定を優先)
NO_WEAPON = 4
# 攻撃回避時の効果音(SEフォルダを参照) EVA_SE = [ファイル名,ボリュ－ム,ピッチ]
EVA_SE = ["063-Swing02", 80, 100]
# ステート拡張・自動復活時のアニメID
RESURRECTION = 26
# 影グラフィック　利用するならtrueしないならfalse
SHADOW = true
# 歩行グラフィック認識　歩行グラを利用するならtrueしないならfalse
# falseにした場合、必ずファイルNo1以降を用意し、ファイルNo0は使わないように
# またNo1以降の画像サイズは統一させる(全キャラ統一ではなくそのキャラで統一)
WALK_ANIME = true
# バトラーグラフィックのアニメセル数（横分割数）
ANIME_PATTERN = 4
# バトラーグラフィックのアニメ種類数（縦分割数）
ANIME_KIND = 4
# 逃走成功メッセージ
RUN_SUCCESS = "逃げ出した！"
# 逃走失敗メッセージ
RUN_NG = "逃走失敗！"
# バックアタック(不意打ちと画面反転)　利用するならtrueしないならfalse
BACK_ATTACK = true
# バックアタック基本確率　これに敵素早さ平均/味方平均を掛けたものが実際の確率
BACK_ATTACK_RATE = 8
# バックアタックを知らせるメッセージ
BACK_ATTACK_COMMENTS = "エネミーのバックアタック！"
# バックアタックで戦闘背景まで反転させないならfalse
BACK_ATTACK_MIRROR = false
# イベント戦闘でも通常通りバックアタック発生計算を行うならtrue
EVENT_BACK_ATTACK = 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
NON_BACK_ATTACK_SWITCH = []
# 必ずバックアタックを発生させるスイッチNo(無効化よりも優先されます)
BACK_ATTACK_SWITCH = []
#==============================================================================
# ■ 単発アクション
#------------------------------------------------------------------------------
# 　通しアクションに利用するものです。これ単体では意味を持ちません。
#==============================================================================
# ここの単発アクション名同士は、かぶらないようにしてください。
# 通しアクション名とかぶる分には問題ありません。
ANIME = {
#--------------------------------------------------------------------------
# ● バトラーアニメ設定
#--------------------------------------------------------------------------
# ファイルNo…利用するグラフィックファイルのナンバー。
# アクターの場合、0は歩行グラフィックを参照します。
# 1以降は"キャラクターグラフィック名+_1"のように_の後のナンバーの
# グラフィックを参照します。例)001-Fighter01_1　のファイルNoは1
# グラフィックは全てキャラクターフォルダから探します。
#
# 種類…グラフィックファイルのセルの縦位置。上から0～3と続きます。
# 速度…アニメの更新速度。数字が低いほど早く更新します。
# ループ… [0=往復ループ] [1=片道ループ] [2=片道のみでループしない]
# 待ち…ループしない(2)場合、最後のアニメを表示してからの待ち（ウエイト）時間。
# 固定…アニメせずに固定する場合、セル番号(横位置)を指定。固定しない通常は-1。
# Z軸…手前に表示するならプラス。通常は画面下ほど手前に表示されます。
# 影…影グラフィックを表示するならtrue、しない場合はfalse
# 武器…武器を表示する場合は武器アクション名を。しない場合は""。
# ﾊﾞﾄﾗｰｱﾆﾒ名ﾌｧｲﾙNo 種類速度ﾙｰﾌﾟ待ち固定 Z軸影武器
"待機" => [ 0, 1, 10, 1, 0, -1, 0, true,"" ],
"待機(固定)" => [ 0, 1, 10, 2, 0, 0, 0, true,"" ],
"右向き(固定)" => [ 0, 2, 10, 1, 2, 0, 0, true,"" ],
"ダメージ" => [ 0, 3, 4, 2, 0, -1, 0, true,"" ],
"戦闘不能" => [ 0, 3, 10, 1, 8, 0, 0,false,"" ],
"前進" => [ 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,"縦振り"],
"武器振り攻撃遅" => [ 0, 1, 3, 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, 14, -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, 20,false,-135, 45, 4,false, 1, 1, -4, -40],
"下半回転" => [ 6, 10,false, 270, 45, 4,false, 1, 1, -4, -32],
"上半回転" => [ 6, 10,false, 45,-100, 4,false, 1, 1, -4, -32],
"掲げ" => [ 6, -2,false, 90, -45, 4,false, 1, 1, -4, -32],
#--------------------------------------------------------------------------
# ● バトラー移動エネミーの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, 12, -1, 0, "前進"],
"一歩後移動" => [ 0, 32, 0, 5, -1, 0, "前進"],
"四人攻撃移動1" => [ 2, 564, 186, 12, -1, 0, "前進"],
"四人攻撃移動2" => [ 2, 564, 212, 12, -1, 0, "前進"],
"四人攻撃移動3" => [ 2, 504, 174, 12, -1, 0, "前進"],
"四人攻撃移動4" => [ 2, 504, 254, 12, -1, 0, "前進"],
"被ダメージ" => [ 0, 32, 0, 3, -1, 0, "ダメージ"],
"押し出す" => [ 0, 12, 0, 1, 1, 0, "ダメージ"],
"味方逃走" => [ 0, 150, 0, 20, 2, 0, "後退"],
"逃走失敗" => [ 0, 48, 0, 10, 1, 0, "後退"],
"勝利のジャンプ" => [ 0, 0, 0, 16, 0, -5, "前進"],
"目標移動" => [ 1, 0, 0, 10, -1, 0, "前進"],
"目標高速移動" => [ 1, 0, -12, 7, 0, -2, "前進"],
"目標前移動" => [ 1, 24, 0, 10, -1, 0, "前進"],
"目標前高速移動" => [ 1, 24, 0, 1, 0, 0, "前進"],
"目標右前移動" => [ 1, 96, 32, 12, -1, 0, "前進"],
"目標左前移動" => [ 1, 96, -32, 12, -1, 0, "前進"],
"一歩前ジャンプ" => [ 0, -32, 0, 5, -1, -4, "前進"],
"一歩後ジャンプ" => [ 0, 32, 0, 5, -1, -4, "後退"],
"目標にジャンプ" => [ 1, 12, -12, 8, -1, -6, "前進"],
"味方投げ" => [ 0, -24, 0, 10, 0, -2, "前進"],
"踏みつけ" => [ 1, 12, -32, 8, -1, -6, "手前表示"],
"一歩前ジャンプ叩き" => [ 0, -32, 0, 8, -1, -2, "武器振り攻撃"],
"前ジャンプ叩き" => [ 1, 12, 0, 8, -1, -5, "武器振り攻撃遅"],
"後方に払い上げ" => [ 1, 12, 0, 10, 0, -3, "武器振り攻撃"],
"その場ジャンプ叩き" => [ 1, 0, 0, 10, 0, -5, "武器振り攻撃"],
"払い抜け" => [ 1, -96, 0, 10, 2, 0, "武器振り攻撃"],
"右払い抜け" => [ 1, -96, 32, 10, 2, 0, "武器振り攻撃"],
"左払い抜け" => [ 1, -96, -32, 10, 2, 0, "武器振り攻撃"],
"右払い抜け2" => [ 1,-128, 48, 10, 2, 0, "武器振り攻撃"],
"左払い抜け2" => [ 1,-128, -48, 10, 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", 12, 0, 0, "前進"],
"後退リセット" => ["reset", 12, 0, 0, "後退"],
#--------------------------------------------------------------------------
# ● 強制アクション　自分以外のバトラーにアクションを取らせます
#--------------------------------------------------------------------------
# 識別…取らせるアクションが単発か通しか。"単発"はここの単発アクション名を。
# "通し"とは単発アクションを組み合わせたものを指します。
#
# 対象…アクションを取らせる対象。0はターゲット、それ以外はそのステートNoが
# 付いているバトラー全部を対象とします。
# 数値に-マイナスを付けることで、その絶対値のスキルIDを習得している
# 自分以外のアクターを対象とします(アクター限定)
# インデックス(メンバー位置)で指定する場合、インデックス値に1000足します。
# 指定したインデックスが自分だったり存在しない場合(戦闘不能や逃走)は
# 0番から順に参照し、誰も該当しなかった時は行動を中断します。
#
# 復帰…アクション後位置を戻すなら座標リセット系の単発アクション名を入れます。
# 戻さない場合""とします。
# アクション名…強制するアクション名。識別が単発なら、単発アクション名を。
# 通しなら通しアクション名を。
# 識別対象復帰アクション名
"小吹き飛ばし" => ["単発", 0, "座標リセット", "押し出す"],
"縦にぺしゃんこ" => ["単発", 0, "座標リセット", "縦縮み"],
"着弾1" => ["単発", 0, "座標リセット", "対象から自身へ1"],
"味方持ち上げ" => ["単発", 0, "", "持ち上げられる"],
"上昇" => ["単発", 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", 0, -90, -90,false],
"右回り1回転" => ["angle", 24, 0,-360,false],
#--------------------------------------------------------------------------
# ● バトラー拡大縮小　武器アクションは反映されません
#--------------------------------------------------------------------------
# 判別…判別に使うので、すべて"zoom"で統一してください。
# 時間…拡大縮小にかける時間。
# X拡…横の拡大率。1.0が等倍で、0.5が半分になります。
# Y拡…縦の拡大率。1.0が等倍で、0.5が半分になります。
# 復帰…trueにすると終了と同時に等倍に戻ります。falseはそのまま。
# 拡大縮小中は一時的に転送元原点が変わりますが、この復帰で元に戻ります。
# 　判別時間 X拡 Y拡復帰
"縦縮み" => ["zoom", 16, 1.0, 0.5, true],
#--------------------------------------------------------------------------
# ● 戦闘アニメ　データベースの戦闘アニメを表示します
#--------------------------------------------------------------------------
# 判別…判別に使うので、すべて"anime"で統一してください。
# ID…アニメID。-1で武器やスキルに設定された対象側アニメになりダメージを表示。
# -2にするとスキルでも武器依存のアニメになります。
# -3にするとスキルに設定された使用側アニメを表示。
# 対象… [0=自分] [1=ターゲット]
# 反転…trueでアニメ画像が反転されます。
# ウエイト…アニメ表示が終わるまで待つならtrue。
# 判別 ID 対象反転ｳｴｲﾄ
"使用側アニメ" => ["anime", -3, 0,false,false],
"対象アニメ" => ["anime", -1, 1,false,false],
"対象アニメウエイト"=> ["anime", -1, 1,false, true],
"対象アニメ武器" => ["anime", -2, 1,false,false],
"打撃アニメ" => ["anime", 4, 1,false,false],
"斬撃/必殺技1" => ["anime", 67, 1,false,false],
"同時攻撃/雷" => ["anime", 34, 1,false,false],
"同時攻撃/土" => ["anime", 40, 1,false,false],
#--------------------------------------------------------------------------
# ● アニメ飛ばし　戦闘アニメを飛ばします。飛び道具、遠距離攻撃用
#--------------------------------------------------------------------------
# ID…データベースで設定されているアニメのID。0はアニメを非表示に。
# 対象…飛ばす対象 [0=ターゲット] [1=敵全体の中心] [2=味方全体の中心] [4=自身]
# タイプ…[0=当たって消える] [1=直線に貫通]
# 時間…アニメを飛ばす際の移動時間。大きいほど速度も遅い。
# 軌道…アニメを飛ばす際の軌道。数値を入れると曲線に。正が下、負が上軌道。
# 調X…微調整するX軸。飛ばす初期X座標が変化します。エネミーは自動で逆計算に。
# 調Y…微調整するY軸。飛ばす初期Y座標が変化します。
# 始…アニメを飛ばす際の開始位置。[0=自身] [1=対象] [2=移動させない]
# ループ…アニメセルを最初にループさせる場合はtrue
# 武器…下の貼り付ける武器アクション名を入れます。武器を表示しないなら""
# 判別 ID 対象ﾀｲﾌﾟ時間軌調X 調Y 始ﾙｰﾌﾟ武器
"魔法始動アニメ" => ["m_a", 1, 4, 0, 25, 0, 0, 0, 2,false,""],
"対象から自身へ1" => ["m_a", 92, 0, 0, 12, 0, 0, 0, 1, true,""],
"武器投げ開始" => ["m_a", 0, 0, 0, 12, -24, 0, 0, 0,false,"回転投げ"],
"武器投げ戻し" => ["m_a", 0, 0, 0, 12, 24, 0, 0, 1,false,"回転投げ"],
"全体アニメ単体化"=> ["m_a",100, 1, 0, 52, 0, 0, 0, 2,false,""],
#--------------------------------------------------------------------------
# ● アニメ飛ばしに貼り付ける武器画像アクション　上のアニメ飛ばし専用
#--------------------------------------------------------------------------
# 貼り付けた武器画像の動き。この画像は武器アクションの画像とは別に設定できます。
# その場合貼り付ける画像は武器設定で行ってください。
# 始度…動作前の最初の角度。半時計回りで0～360度。
# 終度…動作後の角度。半時計回りで0～360度。
# 時間…回転にかける時間。小さいほど早い。動作は消えるまでループし続けます。
# 武器ｱｸｼｮﾝ名　　始度終度時間
"回転投げ" => [ 0, 360, 8],
#--------------------------------------------------------------------------
# ● サウンドの演奏
#--------------------------------------------------------------------------
# 判別…判別に使うので、すべて"sound"で統一してください。
# 種別…効果音は"se" BGMは"bgm" BGSは"bgs"
# ﾋﾟｯﾁ…ピッチ、50～150まで指定。音量…ボリューム　どちらも100がデフォルト。
# ﾌｧｲﾙ名…再生するファイル名。""にするとBGM、BGSを変えずに各種設定可能。
# SE名判別種別ﾋﾟｯﾁ音量 SEﾌｧｲﾙ名
"062-Swing01" => ["sound", "se", 80, 100, "062-Swing01"],
#--------------------------------------------------------------------------
# ● ゲーム全体のスピード変更アクションの細部チェック用
#--------------------------------------------------------------------------
# 判別…判別に使うので、すべて"fps"で統一してください。
# ｹﾞｰﾑｽﾋﾟｰﾄﾞ…60がデフォルトで、低くなるほどスローになります。　
# ※このコマンドはFPSを直接変更するものです。取り扱いには注意してください。
# 　またタイマーカウント、ゲーム内時間もその分ズレることになります。
# 変更名判別ｹﾞｰﾑｽﾋﾟｰﾄﾞ
"スロー再生" => ["fps", 10],
"通常再生に" => ["fps", 40],
#--------------------------------------------------------------------------
# ● ステート付与
#--------------------------------------------------------------------------
# 判別…判別に使うので、すべて"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,"007-Fighter07"],
"変身解除" => ["change", true,"019-Thief04"],
#--------------------------------------------------------------------------
# ● ピクチャの表示バトラー一体につき同時に1枚表示できます
#--------------------------------------------------------------------------
# 始X…移動開始位置。画面から見たX座標。ピクチャの左上を原点とします。
# 始Y…移動開始位置。画面から見たY座標。
# 終X…移動終了X座標。
# 終Y…移動終了Y座標。
# 時間…移動時間。大きいほど遅い。これを距離で割ったのが1フレーム移動距離です。
# Z軸…HPウインドウよりも手前に表示するならtrue
# ﾋﾟｸﾁｬﾌｧｲﾙ名…ピクチャフォルダ内のファイル名。
# 判別始X 始Y 終X 終Y 時間 Z軸ﾋﾟｸﾁｬﾌｧｲﾙ名
"カットイン1始" => ["pic", 0,-480, 0, 0, 8, true,"ピクチャテスト"],
"カットイン1終" => ["pic", 0, 0, 0, 480, 8, true,"ピクチャテスト"],
#--------------------------------------------------------------------------
# ● ゲームスイッチの操作
#--------------------------------------------------------------------------
# 判別…判別に使うので、すべて"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 = {
#------------------------------- 待機系 -----------------------------------------
# 通しアクション名行動
"戦闘開始" => ["戦闘開始前の位置へ","座標リセット"],
"待機" => ["待機"],
"浮遊待機" => ["待機(固定)","6","低空浮遊中","4",
"低空浮遊中2","4","低空浮遊中3","4",
"低空浮遊中4","4"],
"気絶" => ["倒れたまま","戦闘不能"],
"ダメージ" => ["被ダメージ","座標リセット"],
"逃走" => ["味方逃走"],
"エネミー逃走" => ["味方逃走","座標リセット"],
"逃走失敗" => ["逃走失敗","待機(固定)","8","座標リセット"],
"コマンド入力" => ["一歩前移動"],
"コマンド入力後" => ["座標リセット"],
"防御" => ["待機(固定)","4","浮遊ステート確認","低空浮遊中",
"2","低空浮遊中2","2","低空浮遊中3","2",
"低空浮遊中4","2"],
"回避" => ["一歩後ジャンプ","一歩後ジャンプ","待機(固定)","16",
"座標リセット"],
"エネミー回避" => ["一歩後ジャンプ","待機(固定)","16","座標リセット"],
"勝利" => ["待機(固定)","16","右向き(固定)","勝利のジャンプ",
"待機(固定)","待機に移行しない","ネコに変身してるか",
"魔法始動アニメ","変身解除","待機(固定)","待機に移行しない",],
"座標復帰" => ["座標リセット"],
#------------------------------- 強制系 ----------------------------------------
"バジル合体攻撃1" => ["2","目標左前移動","待機(固定)",
"魔法始動アニメ","武器回し下","武器掲げ",
"右払い抜け","32","後退リセット"],
"四人合体攻撃1" => ["2","四人攻撃移動2","待機(固定)","魔法始動アニメ",
"武器回し下","武器掲げ","58",
"左払い抜け","46","後退リセット"],
"四人合体攻撃2" => ["2","四人攻撃移動3","待機(固定)","魔法始動アニメ",
"武器回し下","武器掲げ","16","右払い抜け2","上昇",
"同時攻撃/土","82","後退リセット"],
"四人合体攻撃3" => ["2","四人攻撃移動4","待機(固定)","魔法始動アニメ",
"武器回し下","武器掲げ","左払い抜け2","小吹き飛ばし",
"同時攻撃/雷","94","後退リセット"],
"投げつけられる" => ["右回り1回転","4","目標高速移動","一歩後ジャンプ","4",
"待機(固定)","一歩後ジャンプ","待機(固定)","18"],
#--------------------------- 基本アクション系 ----------------------------------
"通常攻撃" => ["目標前移動","対象アニメ","武器振り攻撃","10",
"コラプス許可","後退リセット"],
"敵武器なし攻撃" => ["目標前移動","対象アニメ","武器振り攻撃","4",
"コラプス許可","後退リセット"],
"汎用スキル使用" => ["一歩前移動","待機(固定)","使用側アニメ",
"武器回し下","武器掲げ","武器振り攻撃",
"対象アニメ","コラプス許可","座標リセット"],
"汎用スキル個別処理"=> ["一歩前移動","使用側アニメ","武器回し下","武器掲げ",
"個別処理開始","武器振り攻撃","対象アニメ","12",
"個別処理終了","コラプス許可","座標リセット"],
"アイテム使用" => ["目標前移動","待機(固定)","8","対象アニメウエイト",
"コラプス許可","座標リセット"],
#------------------------------ スキル系 ---------------------------------------
"多段攻撃" => ["残像ON","前ジャンプ叩き","対象アニメ武器","16",
"対象アニメ武器","武器回し下","武器回し上",
"その場ジャンプ叩き","対象アニメ武器","8",
"対象アニメ武器","反転","武器振り攻撃","8","反転",
"その場ジャンプ叩き","対象アニメ武器","一歩後ジャンプ",
"一歩後ジャンプ","待機(固定)","対象アニメ武器",
"払い抜け","コラプス許可","残像OFF","16","後退リセット"],
"多段攻撃ランダム用"=> ["前ジャンプ叩き","対象アニメ武器","12","待機(固定)",
"前ジャンプ叩き","対象アニメ武器","12","待機(固定)",
"前ジャンプ叩き","対象アニメ武器","12","待機(固定)",
"前ジャンプ叩き","対象アニメ武器","12","コラプス許可","座標リセット"],
"高速多段攻撃" => ["目標前移動","武器振り攻撃","小吹き飛ばし","対象アニメ武器",
"目標前高速移動","武器振り攻撃","小吹き飛ばし","武器振り攻撃L","対象アニメ武器",
"目標前高速移動","武器振り攻撃","小吹き飛ばし","武器振り攻撃L","対象アニメ武器",
"目標前高速移動","武器振り攻撃","小吹き飛ばし","武器振り攻撃L","対象アニメ武器",
"目標前高速移動","武器振り攻撃","小吹き飛ばし","武器振り攻撃L","対象アニメ武器",
"目標前高速移動","武器振り攻撃","小吹き飛ばし","武器振り攻撃L","対象アニメ武器",
"コラプス許可","12","座標リセット"],
"二人同時攻撃" => ["二人攻撃条件確認","二人攻撃目標統一","バジルと攻撃",
"目標右前移動","待機(固定)","魔法始動アニメ","武器回し下",
"武器掲げ","斬撃/必殺技1","左払い抜け","32","対象アニメ",
"コラプス許可","後退リセット","二人攻撃ステート解除"],
"二人同時攻撃準備" => ["二人攻撃ステート付与"],
"四人同時攻撃" => ["四人攻撃条件確認","四人攻撃目標統一","四人で攻撃1",
"四人で攻撃2","四人で攻撃3","四人攻撃移動1","待機(固定)",
"魔法始動アニメ","武器回し下","武器掲げ","58",
"斬撃/必殺技1","右払い抜け","14","対象アニメウエイト",
"コラプス許可","後退リセット","合体攻撃解除"],
"四人同時攻撃準備" => ["四人攻撃ステート付与"],
"武器投げ" => ["一歩前移動","武器振り攻撃","062-Swing01","待機(固定)",
"武器投げ開始","12","対象アニメ武器","コラプス許可",
"武器投げ戻し","座標リセット"],
"個別全体遠距離攻撃"=> ["使用側アニメ","待機(固定)","16","一歩前ジャンプ",
"ジャンプ停止","個別処理開始","標的を自身に","着弾1",
"武器振り攻撃","対象アニメ武器","個別処理終了",
"コラプス許可","ジャンプ着地","座標リセット"],
"全体遠距離攻撃" => ["標的を自身に","武器振り攻撃","着弾1","4",
"対象アニメウエイト","コラプス許可"],
"ヒールに派生" => ["目標前移動","対象アニメ","武器振り攻撃",
"8","ヒールに派生","座標リセット"],
"適当に派生" => ["逃走失敗","魔法始動アニメ","武器回し下","武器掲げ",
"対象アニメウエイト","適当に派生","座標リセット"],
"カットイン" => ["待機(固定)","魔法始動アニメ","カットイン1始",
"40","カットイン1終","目標前移動",
"武器振り攻撃","対象アニメウエイト","コラプス許可",
"ピクチャ消去","後退リセット"],
"踏み潰し" => ["目標にジャンプ","打撃アニメ","縦にぺしゃんこ","一歩後ジャンプ",
"踏みつけ","打撃アニメ","縦にぺしゃんこ","一歩後ジャンプ",
"踏みつけ","対象アニメ","縦にぺしゃんこ","一歩後ジャンプ",
"一歩後ジャンプ","コラプス許可","待機(固定)","8","後退リセット"],
"全体攻撃1" => ["一歩前移動","待機(固定)","魔法始動アニメ","武器回し下",
"武器掲げ","全体アニメ単体化","武器振り攻撃","48",
"対象アニメウエイト","コラプス許可","座標リセット"],
"ネコに変身" => ["一歩前ジャンプ","待機(固定)","魔法始動アニメ","16",
"ネコに変身","待機(固定)","neko","対象アニメウエイト",
"一歩後ジャンプ","座標リセット"],
"味方投げつけ" => ["投げる相手選択","目標移動","味方持ち上げ","4",
"062-Swing01","投げつけ目標セット","味方投げ飛ばし",
"味方投げ","待機(固定)","対象アニメ","コラプス許可",
"座標リセット","待機(固定)","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

复制代码

此贴于 2009-2-13 0:09:14 被版主redant提醒，请楼主看到后对本贴做出回应。

此贴于 2009-2-16 13:36:22 被版主darkten提醒，请楼主看到后对本贴做出回应。

版务信息：本贴由楼主自主结贴～

遠夜 · 发表于 2009-2-13 07:09:18

接楼上的脚本:

#--------------------------------------------------------------------------
# ● 通常待機
#--------------------------------------------------------------------------
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, 0]
end
# 上記のアクターID以外すべてに適用される位置
return [ 0, 0]
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"
end
# 上記のエネミーID以外すべてに適用される影グラフィック
return "shadow01"
end
#--------------------------------------------------------------------------
# ● 影グラフィックの位置を微調整
#--------------------------------------------------------------------------
# return [横座標, 縦座標]
def shadow_plus
case @enemy_id
when 1
return [ 0, 0]
end
# 上記のエネミーID以外すべてに適用される位置
return [ 0, 0]
end
#--------------------------------------------------------------------------
# ● エネミー武器設定アクションとアニメは武器のものに反映されます
#--------------------------------------------------------------------------
# return 1 ←この数字が武器ID。0にすると素手扱いになります。
# エネミーアニメをONにしていると画像も表示されます。
def weapon
case @enemy_id
when 1
return 0
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、ラスボスタイプは4
def collapse_type
case @enemy_id
when 1
return 2
when 33
return 3
when 34
return 4
end
# 上記のエネミーID以外すべてに適用されるコラプス
return 2
end
#--------------------------------------------------------------------------
# ● エネミー行動回数 1ターンに何回行動するか ATBとの併用はできません
#--------------------------------------------------------------------------
# 回数確率補正
# return [ 2, 100, 50]
#
# 回数…最大行動回数
# 確率…次の行動を取る確率。数値は％
# 補正…素早さ補正。行動するたびにこの数値％分素早さが低下
def action_time
case @enemy_id
when 1
return [ 1, 100, 100]
end
# 上記のエネミーID以外すべてに適用される行動回数
return [ 1, 100, 100]
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 21
return "浮遊待機"
end
# 上記IDのステート以外すべてに適用される通しアクション
return "待機"
end
#--------------------------------------------------------------------------
# ● 拡張設定　ステートIDから拡張設定を決めます。重複可能。
#--------------------------------------------------------------------------
# "自動復活/50"…戦闘不能時に自動で復帰。戦闘不能付与で解除されない設定にすること。
# /の後ろの数字は復帰時のHP(最大値からの割合％)復帰後ステートは自動解除される
# "魔法反射/64"…魔法(int_fが0ではない)ｽｷﾙを反射。/の後に反射時のｱﾆﾒIDを入れる
# "物理反射/64"…物理(str_fが0ではない)ｽｷﾙを反射。/の後に反射時のｱﾆﾒIDを入れる
# "魔法無効/65"…魔法(int_fが0ではない)ｽｷﾙを無効化。/の後に無効時のｱﾆﾒIDを入れる
# "物理無効/65"…物理(str_fが0ではない)ｽｷﾙを無効化。/の後に無効時のｱﾆﾒIDを入れる
# "コスト吸収"…受けたスキルのコストを自身に還元。数値はPOPしません
# "0ターン解除"…行動順にかかわらずそのターン終了時にステートを解除
# "エネミー除外"…エネミーに取らせたくないステートアクション
# "ステートアクション禁止"…ステートが付加しても待機アクションに反映させない
# "なし"…拡張なし
def extension
case @id
when 1 # 戦闘不能
return ["エネミー除外"]
when 18
return ["0ターン解除"]
when 19
return ["0ターン解除"]
when 20
return ["ステートアクション禁止"]
when 21
return ["魔法反射/64"]
end
# 上記のID以外すべてに適用される拡張設定
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から拡張設定を決めます。重複可能。
#--------------------------------------------------------------------------
# "絶対先制"…かならずターンの最初に行動
# "絶対後発"…かならずターンの最後に行動
# "SPダメージ"…HPダメージ(回復)処理をそのままSPに変換
# "吸収/50"…与えたダメージの/から後ろの数値％分回復。例だとダメージの50％回復
# "必中"…絶対に攻撃が回避されない
# "HP消費"…SP消費がHP消費に変わる
# "%コストMAX"…スキルコストが最大SP(HP)からの割合に変化。例)MAXSP500でコスト10だとSP50消費に
# "%コストNOW"…スキルコストが現在SP(HP)からの割合に変化
# "反射無視"…魔法・物理スキル反射ステートを無視する
# "%ダメージMAX/30"…ダメージ計算が対象の最大HP(SP)からの割合に変化。/から後の数値%分ダメージ
# "%ダメージNOW/30"…ダメージ計算が対象の現在HP(SP)からの割合に変化。/から後の数値%分ダメージ
# "コスト威力"…使用者の最大SP(HP)に対する消費SP(HP)の割合で威力が変化。MAX消費でそのままの威力、MAXの10%で威力1/10
# "現HP威力"…使用者の最大HPに対する現在HPの割合で威力が変化。MAXでそのままの威力、MAXの10%で威力1/10
# "現SP威力"…使用者の最大SPに対する現在SPの割合で威力が変化。MAXでそのままの威力、MAXの10%で威力1/10
# "ヘルプ非表示"…アクション時、ヘルプウインドウにスキル名を表示しない
# "全域"…ターゲット範囲が敵味方全体に
# "ランダムターゲット"…ターゲット内から一体をランダムで選ぶように
# "自分以外"…ターゲット内から自分を除く
# "ダメージアクション禁止"…ダメージを与えた際のアクションを取らせない
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

复制代码

这是第2个脚本= =
名字是: Sideview 1

#==============================================================================
# ■ Sprite_Battler Ver2.6
#------------------------------------------------------------------------------
# 　バトラー表示用のスプライトです。
#==============================================================================
class Sprite_Battler < RPG::Sprite
#--------------------------------------------------------------------------
# ● オブジェクト初期化
#--------------------------------------------------------------------------
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 # ふきだしアニメ時間
@atb_flug = false # ATB判別
# バトラーがいない場合は処理を中断
return @battler_visible = false if @battler == nil
# バトラーがアクターの場合、またはエネミーアニメがオンの場合
@anime_flug = true if @battler.actor?
@anime_flug = true if [email protected]? && @battler.anime_on
# バトラー作成
make_battler
end
#--------------------------------------------------------------------------
# ● バトラー作成
#--------------------------------------------------------------------------
def make_battler
# 初期配置の取得
@battler.base_position
# 色相はバトラーとして認識
@battler_hue = @battler.battler_hue
# バトラーがアクターの場合、またはエネミーアニメがオンの場合
if @anime_flug
# メイン武器を用意
@weapon_R = Sprite_Weapon.new(viewport,@battler)
# 味方はキャラクター名、エネミーはバトラー名を取得
@battler_name = @battler.character_name if @battler.actor?
@battler_name = @battler.battler_name unless @battler.actor?
# エネミー反転がオンの場合、画像を反転させる
self.mirror = true if [email protected]? && @battler.action_mirror
# 歩行グラフィックを利用するかどうかで転送元の矩形サイズの認識先を変える
self.bitmap = RPG::Cache.character(@battler_name, @battler_hue) if N01::WALK_ANIME
self.bitmap = RPG::Cache.character(@battler_name + "_1", @battler_hue) 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 = RPG::Cache.battler(@battler_name, @battler_hue)
@width = bitmap.width
@height = bitmap.height
end
# バックアタック時には画像を反転させる
unless @back_attack_flug
if self.mirror && $back_attack
self.mirror = false
elsif $back_attack
self.mirror = true
end
@back_attack_flug = true
end
# 位置を初期化
@battler.reset_coordinate
# 原点を決定
self.ox = @width / 2
self.oy = @height
# 画像の縦幅をバトラーに記録
@battler.battler_height = @height
# スプライトの座標を設定
update_move
# アニメ飛ばし用スプライトを用意
@move_anime = Sprite_MoveAnime.new(viewport,battler)
# ピクチャ用スプライトを用意
@picture = Sprite.new
# 影スプライトを用意
make_shadow if N01::SHADOW
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 = RPG::Cache.character(@battler.shadow, @battler_hue)
# 影位置の微調整用インスタンス
@shadow_plus_x = @battler.shadow_plus[0] - @width / 2
@shadow_plus_y = @battler.shadow_plus[1] - @shadow.bitmap.height
# バトラー画像のサイズに合わせて影画像をリサイズ
@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
mirage_off
super
end
#--------------------------------------------------------------------------
# ● ATB判別
#--------------------------------------------------------------------------
def set_atb
@atb_flug = true
end
#--------------------------------------------------------------------------
# ● ダメージアクション action = [アニメID,反転フラグ,リアクション許可]
#--------------------------------------------------------------------------
def damage_action(action)
# 吸収処理
if action[0] == "absorb"
action[0] = nil
now_hp = @battler.hp
now_sp = @battler.sp
@battler.hp += action[3] if action[2] == "hp"
@battler.sp += action[3] if action[2] == "sp"
@battler.damage = now_hp - @battler.hp if action[2] == "hp"
@battler.damage = now_sp - @battler.sp if action[2] == "sp"
@battler.sp_damage = true if @battler.damage != 0 && action[2] == "sp"
action[2] = false
end
@battler.damage = "" if @battler.damage == 0
dam = @battler.damage
# ヒットしている時のみアニメ実行
unless dam == "Miss" or action[0] == nil
@battler.animation_id = action[0]
@battler.animation_hit = true
@battler.anime_mirror = action[1]
end
# ダメージアクション実行
unless dam == nil or dam == "Miss" or dam == "" or action[2] == false
start_action(@battler.damage_hit) if dam > 0
end
# 攻撃が当たっていない場合は回避アクション実行
if dam == "Miss"
start_action(@battler.evasion) if action[2]
Audio.se_play("Audio/SE/" + N01::EVA_SE[0], N01::EVA_SE[1], N01::EVA_SE[2]) if action[2]
end
damage_pop
end
#--------------------------------------------------------------------------
# ● ダメージ数値POP
#--------------------------------------------------------------------------
def damage_pop
@battler.critical = "sp_damage" if @battler.sp_damage
damage(@battler.damage, @battler.critical)
@battler.damage = nil
@battler.sp_damage = false
@battler.critical = false
@battler.damage_pop = false
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
# 戦闘不能を最優先
action = $data_states[1].base_action if @battler.states.include?(1)
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
# オートステート対策として戦闘不能を優先させる処置
if @battler.states.include?(1)
# アクション禁止のステートだったらスキップ
return if $data_states[1].extension.include?("ステートアクション禁止")
# エネミーで禁止されているステートアクションだったらスキップ
return if @battler.is_a?(Game_Enemy) && $data_states[1].extension.include?("エネミー除外")
# ステートのモーションに
return @repeat_action = $data_states[1].base_action
end
# 通常処理
for state in @battler.states.reverse
next if $data_states[state].extension.include?("ステートアクション禁止")
next if @battler.is_a?(Game_Enemy) && $data_states[state].extension.include?("エネミー除外")
@repeat_action = $data_states[state].base_action
end
end
#--------------------------------------------------------------------------
# ● 待機アクションの割り込み
#--------------------------------------------------------------------------
def push_stand_by
reset unless @battler.dead?
action = @battler.normal
action = @battler.pinch if @battler.hp <= @battler.maxhp / 4
action = @battler.defence if @battler.guarding?
# オートステート対策として戦闘不能を優先させる処置
if @battler.states.include?(1)
# アクション禁止のステートだったらスキップ
unless $data_states[1].extension.include?("ステートアクション禁止")
# エネミーで禁止されているステートアクションだったらスキップ
unless @battler.is_a?(Game_Enemy) && $data_states[1].extension.include?("エネミー除外")
# ステートのモーションに
action = $data_states[1].base_action
# 通常処理をスキップさせるフラグオン
skip_flug = true
end
end
end
# 通常処理
unless skip_flug
for state in @battler.states.reverse
next if $data_states[state].extension.include?("ステートアクション禁止")
next if @battler.is_a?(Game_Enemy) && $data_states[state].extension.include?("エネミー除外")
action = $data_states[state].base_action
end
end
@repeat_action = action
# 割り込み
@action.delete("終了")
act = N01::ACTION[action].dup
for i in 0...act.size
@action.push(act[i])
end
@action.push("終了")
@wait = @anime_end = @unloop_wait = 0
end

复制代码

放不下,下一贴继续.....T T

redant · 发表于 2009-2-13 07:11:45

http://rpg.blue/web/htm/news729.htm

这个是全动画的脚本

注释里写的很明白

遠夜 · 发表于 2009-2-13 07:13:15

继续第2个脚本T T

#--------------------------------------------------------------------------
# ● 各種変化を初期化
#--------------------------------------------------------------------------
def reset
self.zoom_x = self.zoom_y = 1
self.oy = @height
@angle = self.angle = 0
@anime_end = true
@non_repeat = false
@anime_freeze = false
@unloop_wait = 0
end
#--------------------------------------------------------------------------
# ● ジャンプを初期化
#--------------------------------------------------------------------------
def jump_reset
@battler.jump = @jump_time = @jump_time_plus = @jump_up = @jump_down = 0
@jump_size = @jump_plus = @float_time = @float_up = 0
end
#--------------------------------------------------------------------------
# ● ターゲット情報を受け取る
#--------------------------------------------------------------------------
def get_target(target)
# 個別処理中は中止(全域で自分が巻き込まれた時ターゲット情報が狂わないように)
return if @battler.individual
@target_battler = target
end
#--------------------------------------------------------------------------
# ● アクション情報をバトラーに格納
#--------------------------------------------------------------------------
def send_action(action)
@battler.play = 0
@battler.play = action if @battler.active
end
#--------------------------------------------------------------------------
# ● バトラー追加
#--------------------------------------------------------------------------
def battler_join
if @battler.exist? && !@battler_visible
# 戦闘不能からの復活なら処理をスキップ
if @battler.revival && @anime_flug
return @battler.revival = false
elsif @battler.revival && !@anime_flug
@battler.revival = false
return self.visible = true
end
@anime_flug = true if @battler.actor?
@anime_flug = true if [email protected]? && @battler.anime_on
make_battler
first_action
end
end
#--------------------------------------------------------------------------
# ● フレーム更新　※再定義
#--------------------------------------------------------------------------
def update
super
# バトラーがいない場合スキップ
return self.bitmap = nil && loop_animation(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
# ダメージPOP監視
damage_pop if @battler.damage_pop
# スプライト監視
update_battler_bitmap
# エフェクト監視
setup_new_effect
# エフェクト更新
update_effect
# ATB更新
update_atb if @atb_flug
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 collapse_action if action[0] == "N01collapse"
# アクティブ中は割り込ませない
return if @battler.active
# 単発ならそのまま行動に直結
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
# 回転時間がなくなったら項目をリセット
@angle = 0 if @angle_time == 0
return self.oy = @height 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
# 復帰フラグがあれば戻す
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_battler_bitmap
return if @graphic_change
if @battler.actor?
actor = $game_party.actors[@battler.index]
if actor.character_name != @battler_name or actor.character_hue != @battler_hue
@battler_name = actor.character_name
@battler_hue = actor.character_hue
@anime_flug = true
make_battler
self.opacity = 0 if @battler.dead? or @battler.hidden
first_action
end
elsif [email protected]?
if @battler.battler_name != @battler_name or @battler.battler_hue != @battler_hue
@battler_name = @battler.battler_name
@battler_hue = @battler.battler_hue
@anime_flug = true if @battler.anime_on
make_battler
self.opacity = 0 if @battler.dead? or @battler.hidden
first_action
end
end
end
#--------------------------------------------------------------------------
# ● 新しいエフェクトの設定
#--------------------------------------------------------------------------
def setup_new_effect
# フラッシュ
if @battler.white_flash
@effect_type = 1
@effect_duration = 16
@battler.white_flash = false
end
# 点滅開始
if @battler.blink && @blink_count == nil
@blink_count = 0
end
# 点滅終了
if [email protected] && @blink_count != nil
@blink_count = nil
self.color.set(0, 0, 0, 0)
end
# 出現
if not @battler_visible and @battler.exist?
@effect_type = 3
@effect_duration = 16
@battler_visible = true
end
# 消滅
if @battler_visible and @battler.hidden
@effect_type = 4
@effect_duration = 32
@battler_visible = false
end
# コラプス
if @battler.collapse
@effect_type = 5
@effect_duration = 48
@battler.collapse = false
@battler_visible = false
end
# ループ戦闘アニメ
if @battler.damage == nil and
@battler.state_animation_id != @state_animation_id
@state_animation_id = @battler.state_animation_id
loop_animation($data_animations[@state_animation_id])
end
# 通常戦闘アニメ
if @battler_visible && @battler.animation_id != 0
animation = $data_animations[@battler.animation_id]
animation(animation, @battler.animation_hit)
animation_mirror if @battler.anime_mirror
@battler.animation_id = 0
@battler.anime_mirror = false
end
end
#--------------------------------------------------------------------------
# ● エフェクトの更新
#--------------------------------------------------------------------------
def update_effect
if @effect_duration > 0
@effect_duration -= 1
update_whiten if @effect_type == 1
update_appear if @effect_type == 3
update_disappear if @effect_type == 4
update_collapse if @effect_type == 5
end
update_blink if @battler.blink
end
#--------------------------------------------------------------------------
# ● 白フラッシュエフェクトの更新
#--------------------------------------------------------------------------
def update_whiten
self.blend_type = 0
self.color.set(255, 255, 255, 128)
self.opacity = 255
self.color.alpha = 128 - (16 - @effect_duration) * 10
end
#--------------------------------------------------------------------------
# ● 点滅エフェクトの更新
#--------------------------------------------------------------------------
def update_blink
@blink_count = (@blink_count + 1) % 32
if @blink_count < 16
alpha = (16 - @blink_count) * 6
else
alpha = (@blink_count - 16) * 6
end
self.color.set(255, 255, 255, alpha)
end
#--------------------------------------------------------------------------
# ● 出現エフェクトの更新
#--------------------------------------------------------------------------
def update_appear
self.blend_type = 0
self.color.set(0, 0, 0, 0)
self.opacity = (16 - @effect_duration) * 16
end
#--------------------------------------------------------------------------
# ● 消滅エフェクトの更新
#--------------------------------------------------------------------------
def update_disappear
self.blend_type = 0
self.color.set(0, 0, 0, 0)
self.opacity = 256 - (32 - @effect_duration) * 10
end
#--------------------------------------------------------------------------
# ● 崩壊エフェクトの更新
#--------------------------------------------------------------------------
def update_collapse
normal_collapse if @collapse_type == 2
boss_collapse1 if @collapse_type == 3
boss_collapse2 if @collapse_type == 4
end
#--------------------------------------------------------------------------
# ● ATB更新
#--------------------------------------------------------------------------
def update_atb
if @battler != nil
if @battler.full_ct and @battler.ct_visible
# CTが溜まったバトラーの色調を変化させる
fullct_color = PARA_CTB::FULL_CT_COLOR
self.tone = fullct_color
else
fullct_color = Tone.new(0,0,0)
self.tone = fullct_color
end
end
end
#--------------------------------------------------------------------------
# ● アクション実行
#--------------------------------------------------------------------------
def action
return if @active_action == nil
action = @active_action[0]
# 反転の場合
return mirroring if action == "反転"
# 回転の場合
return angling if action == "angle"
# 拡大縮小の場合
return zooming if action == "zoom"
# 残像ONの場合
return mirage_on if action == "残像ON"
# 残像OFFの場合
return mirage_off if action == "残像OFF"
# ピクチャ表示の場合
return picture if action == "pic"
# ピクチャ消去の場合
return @picture.visible = false && @picture_time = 0 if action == "ピクチャ消去"
# グラフィックファイル変更の場合
return graphics_change if action == "change"
# 戦闘アニメ表示の場合
return battle_anime if action == "anime"
# ふきだしアニメ表示の場合
return balloon_anime if action == "balloon"
# BGM/BGS/SE演奏の場合
return sound if action == "sound"
# ゲームスイッチ操作の場合
return $game_switches[@active_action[1]] = @active_action[2] if action == "switch"
# ゲーム変数操作の場合
return variable if action == "variable"
# アクション条件の場合
return 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)
# 一時的に原点を中心に変更
self.oy = @height / 2
# 時間が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 = RPG::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]
# イベントの画像変更に引っかからないようフラグを立てる
@graphic_change = true
end
#--------------------------------------------------------------------------
# ● 戦闘アニメ表示 [判別,ID,対象,反転,ウエイト]
#--------------------------------------------------------------------------
def battle_anime
anime_id = @active_action[1]
# バックアタック時にアニメ画像を反転
if $back_attack
mirror = true if @active_action[3] == false
mirror = false if @active_action[3]
else
mirror = @active_action[3]
end
# 使用側アニメの場合
if anime_id == -3 && @battler.active
kind = @battler.current_action.kind
case kind
when 0
weapon_id = @battler.weapon_id if @battler.actor?
weapon_id = @battler.weapon unless @battler.actor?
anime_id = $data_weapons[weapon_id].animation1_id if weapon_id != 0
anime_id = $data_enemies[@battler.id].animation1_id if weapon_id == 0 && [email protected]?
when 1
anime_id = $data_skills[@battler.current_action.skill_id].animation1_id
when 2
anime_id = $data_items[@battler.current_action.item_id].animation1_id
end
# 武器とスキルの対象アニメの場合
elsif anime_id < 0
# 行動の種類でアニメ先を分岐
if @battler.current_action.kind == 1 && anime_id != -2
skill = $data_skills[@battler.current_action.skill_id]
anime_id = skill.animation2_id
elsif @battler.current_action.kind == 2 && anime_id != -2
item = $data_items[@battler.current_action.item_id]
anime_id = item.animation2_id
else
# 武器がなければ素手アニメを使用
anime_id = N01::NO_WEAPON
if @battler.actor?
weapon_id = @battler.weapon_id
anime_id = $data_weapons[weapon_id].animation2_id if weapon_id != 0
else
weapon_id = @battler.weapon
anime_id = $data_weapons[weapon_id].animation2_id if weapon_id != 0
anime_id = $data_enemies[@battler.id].animation2_id if weapon_id == 0
end
end
# ウエイト設定
@wait = $data_animations[anime_id].frame_max * 4 if $data_animations[anime_id] != nil && @active_action[4]
waitflug = true
# ダメージ表示のアニメなら、ダメージ計算を先に済ませるため処理を中断
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_hit = true
@battler.anime_mirror = mirror
elsif $data_animations[anime_id] != nil
for target in @target_battler
target.animation_id = anime_id
target.anime_mirror = mirror
end
end
# ウエイト設定
@wait = $data_animations[anime_id].frame_max * 4 if $data_animations[anime_id] != nil && @active_action[4] && !waitflug
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

复制代码

还是没贴完,下一贴继续.....我晕,这样贴没关系吧....

我的脚本不是楼上的那个呀T T........
而且,就算是楼上的那个我还是没看明白

遠夜 · 发表于 2009-2-13 07:22:17

继续第2个脚本= =....

#--------------------------------------------------------------------------
# ● アクション条件
#--------------------------------------------------------------------------
def necessary
nece1 = @active_action[3]
nece2 = @active_action[4]
# ターゲットチェック
case @active_action[1]
# 0自身 1ターゲット 2敵全体 3味方全体
when 0
target = [$game_party.actors[@battler.index]] if @battler.is_a?(Game_Actor)
target = [$game_troop.enemies[@battler.index]] if @battler.is_a?(Game_Enemy)
when 1
target = @target_battler
when 2
target = $game_troop.enemies
when 3
target = $game_party.actors
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.actors.size if @battler.is_a?(Game_Actor)
state_member = $game_troop.enemies.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 # 現SP
num += member.sp
when 2 # 力
num += member.str
when 3 # 器用さ
num += member.dex
when 4 # 素早さ
num += member.agi
when 5 # 魔力
num += member.int
end
end
# 平均を出す
num = num / target.size
# 条件が満たされていればアクション続行
if num > nece2.abs && num_over
return
elsif num < nece2.abs
return if num_over == nil
end
# スイッチ指定だった場合
when 2
# 条件が満たされていればアクション続行
if $game_switches[nece1]
# 補足がtrueで「スイッチON」、falseは「スイッチOFF」が条件に
return if nece2
# スイッチがOFFの場合はON時とは逆に
else
return unless nece2
end
# 変数指定だった場合
when 3
# 補足が正で「数値以上」、負は「数値以下」が条件に
if nece2 > 0
return if $game_variables[nece1] > nece2
else
return unless $game_variables[nece1] > nece2.abs
end
# 習得スキル指定だった場合
when 4
# スキル条件人数を出す
skill_member = nece2.abs
for member in target
skill_member -= 1 if member.skill_learn?(nece1)
# 条件確認
return if skill_member == 0
end
end
# 条件を満たせなければ以降のアクションを中断
return @action = ["終了"] if @non_repeat
# 防御中は不自然に見えないように座標復帰させない
action = @battler.recover_action
action = @battler.defence if @battler.guarding?
return start_action(action)
end
#--------------------------------------------------------------------------
# ● スキル派生
#--------------------------------------------------------------------------
def derivating
# 未修得スキルは派生不可なら
return unless @active_action[2] && [email protected]_learn?(@active_action[3])
# 確率分岐
return if rand(100) > @active_action[1]
# 派生成功
@battler.derivation = @active_action[3]
# 以降のアクションを中断
@action = ["終了"]
end
#--------------------------------------------------------------------------
# ● 個別処理開始
#--------------------------------------------------------------------------
def individual_action
# リピートフラグオン
@battler.individual = true
# リピートアクションを保持
@individual_act = @action.dup
# ターゲットを保持し、行動ターゲットをひとつずつ抜き出す
send_action(["個別処理"])
@individual_targets = @target_battler.dup
@target_battler = [@individual_targets.shift]
end
#--------------------------------------------------------------------------
# ● 個別処理終了
#--------------------------------------------------------------------------
def individual_action_end
# ターゲットが残っていないなら行動終了
return @battler.individual = false if @individual_targets.size == 0
@action = @individual_act.dup
@target_battler = [@individual_targets.shift]
end
#--------------------------------------------------------------------------
# ● 待機に移行しない
#--------------------------------------------------------------------------
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.actors if @battler.actor?
members = $game_troop.enemies 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.actors + $game_troop.enemies
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.actors
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.enemies
target.add_state(state_id)
end
when 3
for target in $game_party.actors
target.add_state(state_id)
end
when 4
for target in $game_party.actors
if target.index != @battler.index
target.add_state(state_id)
end
end
end
# 行動不能のステートが付いた場合、アクション終了
start_action(@battler.recover_action) unless @battler.movable?
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.enemies
target.remove_state(state_id)
end
when 3
for target in $game_party.actors
target.remove_state(state_id)
end
when 4
for target in $game_party.actors
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.actors if @battler.actor?
members = $game_troop.enemies 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.actors + $game_troop.enemies
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.actors
# 自分は除く
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 = 640 + xx - self.x if $back_attack
else
@distanse_x = self.x - xx
@distanse_x = self.x - (Graphics.width + xx) if $back_attack
end
@distanse_y = @active_action[2] - self.y
when 3 # 初期位置
# X座標はアクターとエネミーで逆計算
if @battler.is_a?(Game_Actor)
@distanse_x = xx + @battler.base_position_x - self.x
else
@distanse_x = xx + self.x - @battler.base_position_x
end
@distanse_y = @active_action[2] + @battler.base_position_y - @battler.position_y
end
@move_speed_x = @active_action[3]
@move_speed_y = @active_action[3]
@move_boost_x = @active_action[4]
@move_boost_y = @active_action[4]
@jump = @active_action[5]
@jump_plus = 0
# 移動計算
move_distance
# 移動アニメ設定を反映
if @anime_flug
move_anime = N01::ANIME[@active_action[6]]
# グラフィック指定がない場合はスキップ
if move_anime != nil
# 現在のアクションを上書き
@active_action = move_anime
# バトラーアニメ開始
battler_anime
end
# 移動が完了したら即アニメが終わるように
@anime_end = true
end
end
#--------------------------------------------------------------------------
# ● 移動計算
#--------------------------------------------------------------------------
def move_distance
# 速度が0の場合、その場に留まる
if @move_speed_x == 0
@moving_x = 0
@moving_y = 0
else
# １フレームあたりの移動距離を計算
@moving_x = @distanse_x / @move_speed_x
@moving_y = @distanse_y / @move_speed_y
# 余った距離はこの時点で移動し消化
over_x = @distanse_x % @move_speed_x
over_y = @distanse_y % @move_speed_y
@move_x += over_x
@move_y += over_y
@battler.move_x = @move_x
@battler.move_y = @move_y
@distanse_x -= over_x
@distanse_y -= over_y
end
# 移動があるかどうかの判定
if @distanse_x == 0
@move_speed_x = 0
end
if @distanse_y == 0
@move_speed_y = 0
end
# X座標移動計算
# 加減速による移動フレーム数の修正
boost_x = @moving_x
move_x = 0
# 加速がある場合
if @move_boost_x > 0 && @distanse_x != 0
# 加減速の正負を左右移動に合わせて変換
if @distanse_x == 0
@move_boost_x = 0
elsif @distanse_x < 0
@move_boost_x *= -1
end
# 距離の変化を事前計算
for i in 0...@move_speed_x
boost_x += @move_boost_x
move_x += boost_x
# オーバー距離を記録
over_distance = @distanse_x - move_x
# 右移動で距離オーバーする直前が何フレーム目だったか記録
if @distanse_x > 0 && over_distance < 0
@move_speed_x = i
break
# 左移動で距離オーバーする直前が何フレーム目だったか記録
elsif @distanse_x < 0 && over_distance > 0
@move_speed_x = i
break
end
end
# オーバー距離を一回前に戻す
before = over_distance + boost_x
# 余った距離を等速移動させるフレーム数を加算
@move_speed_plus_x = (before / @moving_x).abs
# それでも余った距離はこの時点で移動し消化
@move_x += before % @moving_x
@battler.move_x = @move_x
# 減速がある場合
elsif @move_boost_x < 0 && @distanse_x != 0
# 加減速の正負を左右移動に合わせて変換
if @distanse_x == 0
@move_boost_x = 0
elsif @distanse_x < 0
@move_boost_x *= -1
end
# 距離の変化を事前計算
for i in 0...@move_speed_x
boost_x += @move_boost_x
move_x += boost_x
# 足りない距離を記録
lost_distance = @distanse_x - move_x
before = lost_distance
# 右移動で速度が0になる直前が何フレーム目だったか記録
if @distanse_x > 0 && boost_x < 0
@move_speed_x = i - 1
# 足りない距離を一回前に戻す
before = lost_distance + boost_x
break
# 左移動で速度が0になる直前が何フレーム目だったか記録
elsif @distanse_x < 0 && boost_x > 0
@move_speed_x= i - 1
# 足りない距離を一回前に戻す
before = lost_distance + boost_x
break
end
end
# 足りない距離を等速移動させるフレーム数を加算
plus = before / @moving_x
@move_speed_plus_x = plus.abs
# それでも余った距離はこの時点で移動し消化
@move_x += before % @moving_x
@battler.move_x = @move_x
end
# Y座標移動計算
# 加減速による移動フレーム数の修正
boost_y = @moving_y
move_y = 0
# 加速がある場合
if @move_boost_y > 0 && @distanse_y != 0
# 加減速の正負を左右移動に合わせて変換
if @distanse_y == 0
@move_boost_y = 0
elsif @distanse_y < 0
@move_boost_y *= -1
end
# 距離の変化を事前計算
for i in 0...@move_speed_y
boost_y += @move_boost_y
move_y += boost_y
# オーバー距離を記録
over_distance = @distanse_y - move_y
# 右移動で距離オーバーする直前が何フレーム目だったか記録
if @distanse_y > 0 && over_distance < 0
@move_speed_y = i
break
# 左移動で距離オーバーする直前が何フレーム目だったか記録
elsif @distanse_y < 0 && over_distance > 0
@move_speed_y = i
break
end
end
# オーバー距離を一回前に戻す
before = over_distance + boost_y
# 余った距離を等速移動させるフレーム数を加算
@move_speed_plus_y = (before / @moving_y).abs
# それでも余った距離はこの時点で移動し消化
@move_y += before % @moving_y
@battler.move_y = @move_y
# 減速がある場合
elsif @move_boost_y < 0 && @distanse_y != 0
# 加減速の正負を左右移動に合わせて変換
if @distanse_y == 0
@move_boost_y = 0
elsif @distanse_y < 0
@move_boost_y *= -1
end
# 距離の変化を事前計算
for i in 0...@move_speed_y
boost_y += @move_boost_y
move_y += boost_y
# 足りない距離を記録
lost_distance = @distanse_y - move_y
before = lost_distance
# 右移動で速度が0になる直前が何フレーム目だったか記録
if @distanse_y > 0 && boost_y < 0
@move_speed_y = i
# 足りない距離を一回前に戻す
before = lost_distance + boost_y
break
# 左移動で速度が0になる直前が何フレーム目だったか記録
elsif @distanse_y < 0 && boost_y > 0
@move_speed_y = i
# 足りない距離を一回前に戻す
before = lost_distance + boost_y
break
end
end
# 足りない距離を等速移動させるフレーム数を加算
plus = before / @moving_y
@move_speed_plus_y = plus.abs
# それでも余った距離はこの時点で移動し消化
@move_y += before % @moving_y
@battler.move_y = @move_y
end
# 移動完了時間を算出
x = @move_speed_plus_x + @move_speed_x
y = @move_speed_plus_y + @move_speed_y
if x > y
end_time = x
else
end_time = y
end
# 移動が完了するまで次のアクションに行かない
@wait = end_time
# ジャンプ計算
if @jump != 0
# 移動がなくジャンプのみの場合
if @wait == 0
# 時間に計上
@wait = @active_action[3]
end
# 移動完了時間からジャンプ時間を算出
@jump_time = @wait / 2
# 割り切れない場合の余り時間
@jump_time_plus = @wait % 2
# ジャンプの正負を判別
@jump_sign = 0
@jump_sign2 = 0
if @jump < 0
@jump_sign = -1
@jump_sign2 = 1
@jump = @jump * -1
else
@jump_sign = 1
@jump_sign2 = -1
end
# ジャンプ初速度を決定
@jump_up = 2 ** @jump * @jump_sign
# ジャンプ時間の端数を微調整
if @jump_time == 0
@jump_up = 0
elsif @jump_time != 1
@jump_size = @jump_up * @jump_sign * @jump_sign2
else
@jump_size = @jump_up * 2 * @jump_sign * @jump_sign2
@jump_flug = true
end
end
end
#--------------------------------------------------------------------------
# ● バトラーアニメ開始
#--------------------------------------------------------------------------
def battler_anime
# アニメ設定を反映
@anime_kind = @active_action[1]
@anime_speed = @active_action[2]
@anime_loop = @active_action[3]
# ウエイト時間があれば加算
@unloop_wait = @active_action[4]
@anime_end = true
# 武器アクションがある場合だけ更新する
if @weapon_R != nil && @active_action[8] != ""
# 武器の設定をチェック
weapon_kind = N01::ANIME[@active_action[8]]
# 初期化
@weapon_R.action_reset
# アニメパターンが固定だった場合の武器位置を取得
@weapon_R.freeze(@active_action[5]) if @active_action[5] != -1
# 武器画像を設定
@weapon_R.weapon_graphics
# 武器アクションを渡す
@weapon_R.weapon_action(@active_action[8],@anime_loop)
@weapon_action = true
# 最初の武器アクションを更新
@weapon_R.action
elsif @weapon_R != nil
@weapon_R.action_reset
end
@anime_end = false
# アニメパターンが固定だった場合
if @active_action[5] != -1
# アニメが常に終了しているとみなす
@anime_freeze = @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 = RPG::Cache.character(file_name, @battler_hue)
# 転送元の矩形を設定
@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 = 0
# 対象が単体の場合
if target == 0
# ターゲットが決まってない場合、自身に変換
if @target_battler == nil or @target_battler[0] == nil
x = self.x
y = self.y
else
x = @target_battler[0].position_x
y = @target_battler[0].position_y - @target_battler[0].battler_height / 2
end
# 対象が敵の中心の場合
elsif target == 1
targets = $game_troop.enemies if @battler.is_a?(Game_Actor)
targets = $game_party.actors if @battler.is_a?(Game_Enemy)
for target in targets
x += target.position_x
y += target.position_y - target.battler_height / 2
end
x = x / targets.size
y = y / targets.size
# 対象が味方の中心の場合
elsif target == 2
targets = $game_party.actors if @battler.is_a?(Game_Actor)
targets = $game_troop.enemies if @battler.is_a?(Game_Enemy)
for target in targets
x += target.position_x
y += target.position_y - target.battler_height / 2
mem += 1
end
x = x / targets.size
y = y / targets.size
# 対象が自身の場合
else
x = self.x
y = self.y - @battler.battler_height / 2
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
# 飛ばす武器グラフィックが指定されているかチェック
weapon_id = @battler.weapon_id if @battler.actor?
weapon_id = @battler.weapon unless @battler.actor?
# 素手でなければ
if weapon_id != 0
weapon_file = $data_weapons[weapon_id].flying_graphic
# 別画像が指定されていなければ既存の武器グラフィックを取得
if weapon_file == ""
weapon_name = $data_weapons[weapon_id].graphic
# さらに指定がなければアイコングラフィックを利用
weapon_name = $data_weapons[weapon_id].icon_name if weapon_name == ""
# 指定されていればそのグラフィック名を取得
else
weapon_name = weapon_file
end
# 武器アクション情報を取得
weapon = @active_action[10]
# 素手なら表示しない
else
weapon = ""
end
end
# ループするか
loop = @active_action[9]
# 以上の情報を全てアニメ飛ばしスプライトに送る
@move_anime.anime_action(id,mirror,distanse_x,distanse_y,type,speed,orbit,weapon,weapon_name,loop)
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 = 5
@collapse_type = @battler.collapse_type unless @battler.actor?
@battler_visible = false unless @battler.actor?
@effect_duration = N01::COLLAPSE_WAIT + 32 if @collapse_type == 2
@effect_duration = 360 if @collapse_type == 3
@effect_duration = 560 if @collapse_type == 4
end
#--------------------------------------------------------------------------
# ● ノーマルコラプス
#--------------------------------------------------------------------------
def normal_collapse
if @effect_duration == 31
$game_system.se_play($data_system.enemy_collapse_se)
self.blend_type = 1
self.color.set(255, 64, 64, 255)
end
self.opacity = 256 - (48 - @effect_duration) * 6 if @effect_duration <= 31
end
#--------------------------------------------------------------------------
# ● ボスコラプス1
#--------------------------------------------------------------------------
def boss_collapse1
if @effect_duration == 320
Audio.se_play("Audio/SE/124-Thunder02", 100, 80)
self.flash(Color.new(255, 255, 255), 60)
viewport.flash(Color.new(255, 255, 255), 20)
end
if @effect_duration == 290
Audio.se_play("Audio/SE/124-Thunder02", 100, 80)
self.flash(Color.new(255, 255, 255), 60)
viewport.flash(Color.new(255, 255, 255), 20)
end
if @effect_duration == 250
Audio.se_play("Audio/SE/049-Explosion02",100, 50)
reset
self.blend_type = 1
self.color.set(255, 128, 128, 128)
end
if @effect_duration < 250
self.src_rect.set(0, @effect_duration - 250, @width, @height - @shadow.bitmap.height / 2)
self.x += 10 if @effect_duration % 2 == 0
self.opacity = @effect_duration - 20
return if @effect_duration < 100
Audio.se_play("Audio/SE/049-Explosion02",100, 50) if @effect_duration % 80 == 0
end
end
#--------------------------------------------------------------------------
# ● ボスコラプス2
#--------------------------------------------------------------------------
def boss_collapse2
duration = @effect_duration
if duration == 550
Audio.bgm_fade(2000)
Audio.bgs_fade(2000)
end
if duration == 440 or duration == 380 or duration == 280 or duration == 180
Audio.se_play("Audio/SE/124-Thunder02", 100, 100)
self.flash(Color.new(255, 255, 255), 60)
viewport.flash(Color.new(255, 255, 255), 20)
end
if duration == 420 or duration == 360 or duration == 260 or duration == 160
Audio.se_play("Audio/SE/124-Thunder02", 100, 50)
self.flash(Color.new(255, 255, 255), 60)
viewport.flash(Color.new(255, 255, 255), 20)
end
if duration == 350
Audio.se_play("Audio/SE/137-Light03",80, 50)
reset
self.blend_type = 1
self.color.set(255, 255, 255, 128)
end
if duration < 350 && duration > 40
self.src_rect.set(175 - duration / 2, duration / 2 - 175, @width, @height - @shadow.bitmap.height / 2)
self.x += 10 if duration % 2 == 0
self.opacity = duration - 60
self.color.set(255, 255, 255, duration / 2 - 35)
viewport.color = Color.new(255, 255, 255, 350 - duration)
Audio.se_play("Audio/SE/137-Light03",80, 50) if duration % 90 == 0
end
Audio.se_play("Audio/SE/137-Light03",80, 30) if duration == 38
viewport.color = Color.new(255, 255, 255, duration * 6) if duration < 40
end
end

复制代码

第2个脚本贴完了
我总感觉是脚本里的某几句,但是我就是不知道是哪几句T T

遠夜 · 发表于 2009-2-13 07:25:06

还有第3个脚本,最长的那个....但是我不知道需要不需要贴....
名字是这个: Sideview 2

开头是这样的:

#==============================================================================
# ■ Scene_Battle Ver2.6
#------------------------------------------------------------------------------
# 　バトル画面の処理を行うクラスです。
#==============================================================================
class Scene_Battle
#--------------------------------------------------------------------------
# ● フレーム更新 ※再定義
#--------------------------------------------------------------------------
def update
# バトルイベント実行中
update_battle_event if $game_system.battle_interpreter.running?
# ATB更新(@countupの有無で判別)
update_countup if @countup != nil && !$game_system.battle_interpreter.running?
# システム (タイマー)、画面を更新
$game_system.update
$game_screen.update
# タイマー0でバトル中断
$game_temp.battle_abort = true if $game_system.timer_working and $game_system.timer == 0
# ウィンドウを更新
@help_window.update
@party_command_window.update
@actor_command_window.update
@status_window.update
@message_window.update
# スプライトセットを更新
@spriteset.update
# トランジション処理中
update_transition if $game_temp.transition_processing
# メッセージウィンドウ表示中
return if $game_temp.message_window_showing
# エフェクト表示中
return if @spriteset.effect?
# タイトル画面に戻す場合
return $scene = Scene_Title.new if $game_temp.to_title
# バトル中断
return battle_break if $game_temp.battle_abort
# ウェイト中
return @wait_count -= 1 if @wait_count > 0
# ゲームオーバー
return $scene = Scene_Gameover.new if $game_temp.gameover
# アクション強制バトラーが存在せず、バトルイベントが実行中の場合
return if $game_temp.forcing_battler == nil and $game_system.battle_interpreter.running?
# フェーズによって分岐
case @phase
when 1 # プレバトルフェーズ
update_phase1
when 2 # パーティコマンドフェーズ
update_phase2
when 3 # アクターコマンドフェーズ
update_phase3
when 4 # メインフェーズ
update_phase4
when 5 # アフターバトルフェーズ
update_phase5
end
end
#--------------------------------------------------------------------------
# ● 基本更新処理
#--------------------------------------------------------------------------
def update_basic
Graphics.update # ゲーム画面を更新
Input.update # 入力情報を更新
$game_system.update # タイマーを更新
$game_screen.update # スクリーン更新
@spriteset.update # スプライトセットを更新
# アニメウエイトOFFならゲージを止めない(ATB用)
update_countup if @countup != nil && !PARA_CTB::ANIMATION_WAIT && !@atb_back_attack
end
#--------------------------------------------------------------------------
# ● 基本更新処理 (エフェクト表示中ウエイト)
#--------------------------------------------------------------------------
def update_effect_wait
loop do
update_basic
# エフェクトが終わるまで待つ
break unless @spriteset.effect?
end
end
#--------------------------------------------------------------------------
# ● 一定時間ウェイト
#--------------------------------------------------------------------------
def wait(duration)
for i in 0...duration
update_basic
end
end
#--------------------------------------------------------------------------
# ● 状況メッセージ(バックアタック・逃走)表示
#--------------------------------------------------------------------------
def battle_message(text)
@help_window.set_text(text, 1)
loop do
update_basic
# Cボタンが押されるまで待つ
break @help_window.visible = @atb_back_attack = false if Input.trigger?(Input::C)
end
end
#--------------------------------------------------------------------------
# ● トランジション更新
#--------------------------------------------------------------------------
def update_transition
# トランジション処理中フラグをクリア
$game_temp.transition_processing = false
# トランジション実行
if $game_temp.transition_name == ""
Graphics.transition(20)
else
Graphics.transition(40, "Graphics/Transitions/" + $game_temp.transition_name)
end
end
#--------------------------------------------------------------------------
# ● バトルイベント更新
#--------------------------------------------------------------------------
def update_battle_event
# インタプリタを更新
$game_system.battle_interpreter.update
# アクションを強制されているバトラーが存在しない場合
if $game_temp.forcing_battler == nil
# バトルイベントの実行が終わった場合
unless $game_system.battle_interpreter.running?
# 戦闘継続の場合、バトルイベントのセットアップを再実行
setup_battle_event unless judge
end
# アフターバトルフェーズでなければ
return if @phase == 5
# ステータスウィンドウをリフレッシュ
@status_window.refresh
# エネミー名リストを更新(パラ犬印のATB用)
@status_window2.refresh if @status_window2 != nil
end
end
#--------------------------------------------------------------------------
# ● ATB更新
#--------------------------------------------------------------------------
def update_countup
return update_ct if PARA_CTB::CT_SKIP == 0
return @ct_wait -= 1 if @ct_wait > 0
update_ct
@ct_wait = PARA_CTB::CT_SKIP
end
#--------------------------------------------------------------------------
# ● バトル中断
#--------------------------------------------------------------------------
def battle_break
# バトル開始前の BGM に戻す
$game_system.bgm_play($game_temp.map_bgm)
# バトル終了
battle_end(3)
end
#--------------------------------------------------------------------------
# ● プレバトルフェーズ開始
#--------------------------------------------------------------------------
alias start_phase1_n01 start_phase1
def start_phase1
start_phase1_n01
# ATB判別
@spriteset.set_atb if @countup != nil
# バックアタックが発生した場合
return unless $back_attack
@atb_back_attack = true
battle_message(N01::BACK_ATTACK_COMMENTS)
# ATBがある場合
if @countup != nil
# アクターのCTを0に
for actor in $game_party.actors
clear_ct(actor)
end
# エネミーのCTを2倍に
for enemy in $game_troop.enemies
declease_ct(enemy,200)
end
return
end
# パーティ全員のアクションをクリア
$game_party.clear_actions
# メインフェーズ開始
start_phase4
end
#--------------------------------------------------------------------------
# ● 勝敗判定
#--------------------------------------------------------------------------
alias judge_n01 judge
def judge
# 勝利判定
win = true
for enemy in $game_troop.enemies
win = false if enemy.exist?
boss_wait1 = true if enemy.collapse_type == 3
boss_wait2 = true if enemy.collapse_type == 4
end
if win
wait(N01::WIN_WAIT)
# ボスコラプスはウエイトを長く挟む
wait(380) if boss_wait1
wait(640) if boss_wait2
# 動けないアクターを除いて勝利アクション
for actor in $game_party.actors
@spriteset.set_action(true, actor.index,actor.win) unless actor.restriction == 4
end
# CTを初期化(ATB用)
initialize_ct if @countup != nil
end
judge_n01
end
#--------------------------------------------------------------------------
# ● バトル終了 result : 結果 (0:勝利 1:逃走 2:敗北 3:中断)
#--------------------------------------------------------------------------
alias battle_end_n01 battle_end
def battle_end(result)
# 逃走成功
if result == 1
# パーティコマンドウィンドウを無効化
@party_command_window.active = @party_command_window.visible = false
for actor in $game_party.actors
@spriteset.set_action(true, actor.index,actor.run_success) unless actor.restriction == 4
end
battle_message(N01::RUN_SUCCESS)
end
# バトル中断を通常処理に戻す
result = 1 if result == 3
battle_end_n01(result)
end
#--------------------------------------------------------------------------
# ● フレーム更新 (パーティコマンドフェーズ : 逃げる)
#--------------------------------------------------------------------------
alias update_phase2_escape_n01 update_phase2_escape
def update_phase2_escape
update_phase2_escape_n01
# パーティコマンドウィンドウを無効化
@party_command_window.active = @party_command_window.visible = false
# 逃走失敗
return unless @phase == 4
for actor in $game_party.actors
@spriteset.set_action(true, actor.index,actor.run_ng) unless actor.restriction == 4
end
battle_message(N01::RUN_NG)
end
#--------------------------------------------------------------------------
# ● 次のアクターのコマンド入力へ
#--------------------------------------------------------------------------
alias phase3_next_actor_n01 phase3_next_actor
def phase3_next_actor
# 動けるキャラのみコマンドアクション
if @active_battler != nil && @active_battler.inputable?
@spriteset.set_action(true, @actor_index, @active_battler.command_a)
end
# 最後のアクターの場合、アクションが終わるまで待つ(ATBがなければ)
@wait_count = 24 if @countup == nil && @actor_index == $game_party.actors.size-1
# ATBがあるかで分岐
phase3_next_actor_n01 if @countup == nil
phase3_next_actor_for_atb if @countup != nil
# 動けるキャラのみコマンドアクション
if @active_battler != nil && @active_battler.inputable?
@spriteset.set_action(true, @actor_index,@active_battler.command_b)
end
end
#--------------------------------------------------------------------------
# ● 前のアクターのコマンド入力へ
#--------------------------------------------------------------------------
alias phase3_prior_actor_n01 phase3_prior_actor
def phase3_prior_actor
# 動けるキャラのみコマンドアクション
if @active_battler != nil && @active_battler.inputable?
@active_battler.current_action.clear
@spriteset.set_action(true, @actor_index,@active_battler.command_a)
end
# ATBがあるかで分岐
phase3_prior_actor_n01 if @countup == nil
phase3_prior_actor_for_atb if @countup != nil
# 動けるキャラのみコマンドアクション
if @active_battler != nil && @active_battler.inputable?
@active_battler.current_action.clear
@spriteset.set_action(true, @actor_index,@active_battler.command_b)
end
end
#--------------------------------------------------------------------------
# ● 次のアクターのコマンド入力へ(ATB用)
#--------------------------------------------------------------------------
def phase3_next_actor_for_atb
# ループ
begin
# アクターの明滅エフェクト OFF
@active_battler.blink = false if @active_battler != nil
# 最後のキャラでメインフェーズ開始
return start_phase4 if @actor_array_index + 1 == @pre_action_battlers.size
return start_phase4 if $game_troop.enemies.include?(@pre_action_battlers[@actor_array_index + 1])
# アクターのインデックスを進める
@actor_array_index += 1
@actor_index = @pre_action_battlers[@actor_array_index].index
@active_battler = $game_party.actors[@actor_index]
@active_battler.blink = true
@active_battler.current_action.clear
# アクターがコマンド入力を受け付けない状態ならもう一度
end until @active_battler.inputable?
# アクターコマンドウィンドウをセットアップ
phase3_setup_command_window
end
#--------------------------------------------------------------------------
# ● 前のアクターのコマンド入力へ(ATB用)
#--------------------------------------------------------------------------
def phase3_prior_actor_for_atb
# ループ
begin
# アクターの明滅エフェクト OFF
@active_battler.blink = false if @active_battler != nil
# 最初のアクターの場合アクターコマンドフェーズ開始
return start_phase2 if @actor_array_index <= 0
# アクターのインデックスを戻す
@actor_array_index -= 1
@actor_index = @pre_action_battlers[@actor_array_index].index
@active_battler = $game_party.actors[@actor_index]
@active_battler.blink = true
@active_battler.current_action.clear
# アクターがコマンド入力を受け付けない状態ならもう一度
end until @active_battler.inputable?
# アクターコマンドウィンドウをセットアップ
phase3_setup_command_window
end
#--------------------------------------------------------------------------
# ● アクターコマンドウィンドウのセットアップ
#--------------------------------------------------------------------------
alias phase3_setup_command_window_n01 phase3_setup_command_window
def phase3_setup_command_window
phase3_setup_command_window_n01
# コマンドウインドウ位置を微調整
unless $back_attack
adjuster_x = N01::COMMAND_POSITION[0]
adjuster_y = N01::COMMAND_POSITION[1]
# バックアタック用調整
else
adjuster_x = N01::COMMAND_POSITION_BACKATTACK[0]
adjuster_y = N01::COMMAND_POSITION_BACKATTACK[1]
end
# コマンド位置を決定
@actor_command_window.x = @active_battler.position_x + adjuster_x
@actor_command_window.y = @active_battler.position_y + adjuster_y
@actor_command_window.z = 9999
end
#--------------------------------------------------------------------------
# ● エネミー選択開始
#--------------------------------------------------------------------------
alias start_enemy_select_n01 start_enemy_select
def start_enemy_select
# 拡張設定を調べる
extension = $data_skills[@skill.id].extension if @active_battler.current_action.kind == 1
extension = $data_items[@item.id].extension if @active_battler.current_action.kind == 2
if extension != nil
if extension.include?("全域") or extension.include?("ランダムターゲット")
# 選択終了
end_skill_select if @active_battler.current_action.kind == 1
end_item_select if @active_battler.current_action.kind == 2
# 次のアクターのコマンド入力へ
phase3_next_actor
return
end
end
start_enemy_select_n01
end
#--------------------------------------------------------------------------
# ● アクター選択開始
#--------------------------------------------------------------------------
alias start_actor_select_n01 start_actor_select
def start_actor_select
# 拡張設定を調べる
extension = $data_skills[@skill.id].extension if @active_battler.current_action.kind == 1
extension = $data_items[@item.id].extension if @active_battler.current_action.kind == 2
if extension != nil
if extension.include?("全域") or extension.include?("ランダムターゲット")
# 選択終了
end_skill_select if @active_battler.current_action.kind == 1
end_item_select if @active_battler.current_action.kind == 2
# 次のアクターのコマンド入力へ
phase3_next_actor
return
end
end
start_actor_select_n01
end
#--------------------------------------------------------------------------
# ● 行動順序作成
#--------------------------------------------------------------------------
alias make_action_orders_n01 make_action_orders
def make_action_orders
make_action_orders_n01
# 拡張設定があるかチェック
for battler in @action_battlers
skill_id = battler.current_action.skill_id
item_id = battler.current_action.item_id
next if battler.current_action.kind == 0
extension = $data_skills[skill_id].extension if skill_id != 0
extension = $data_items[item_id].extension if item_id != 0
battler.current_action.speed = 9999 if extension.include?("絶対先制")
battler.current_action.speed = -1 if extension.include?("絶対後発")
end
# 再度アクションスピードの大きい順に並び替え
@action_battlers.sort! {|a,b|
b.current_action.speed - a.current_action.speed }
# エネミーの行動回数チェック
for enemy in $game_troop.enemies
if enemy.action_time[0] != 1
action_time = 0
# 確率から回数を取得
for i in 1...enemy.action_time[0]
action_time += 1 if rand(100) < enemy.action_time[1]
end
enemy.act_time = action_time
action_time.times do
enemy_order_time(enemy)
action_time -= 1
break if action_time == 0
end
enemy.adj_speed = nil
end
end
end
#--------------------------------------------------------------------------
# ● エネミーの行動回数作成
#--------------------------------------------------------------------------
def enemy_order_time(enemy)
enemy.make_action_speed2(enemy.action_time[2])
select_time = 0
for member in @action_battlers
select_time += 1
break @action_battlers.push(enemy) if member.current_action.speed < enemy.adj_speed
break @action_battlers.push(enemy) if select_time == @action_battlers.size
end
end
#--------------------------------------------------------------------------
# ● フレーム更新 (メインフェーズステップ 1 : アクション準備)
#--------------------------------------------------------------------------
alias update_phase4_step1_n01 update_phase4_step1
def update_phase4_step1
# エフェクト表示中の場合
return if @spriteset.effect?
# ウェイト中の場合
return @wait_count -= 1 if @wait_count > 0
# 未行動バトラーが存在しない場合 (全員行動した)
turn_end if @action_battlers.size == 0
# スリップダメージチェック
@slip_flug = false
if @action_battlers[0] != nil
# フラグオン
@slip_flug = true if @action_battlers[0].hp > 0 and @action_battlers[0].slip_damage?
end
# スリップダメージによる勝敗判定
judge if @battle_end
# 呼び戻す
update_phase4_step1_n01 unless @battle_end
# スリップダメージで戦闘不能になったか
if @slip_flug && @active_battler.dead?
# コラプス処理
@active_battler.perform_collapse
# 待機アクション反映
@spriteset.set_stand_by_action(@active_battler.actor?, @active_battler.index)
# 全滅判定が真、またはパーティ人数が 0 人の場合
return @battle_end = true if $game_party.all_dead? or $game_party.actors.size == 0
# エネミーが 1 体でも存在すれば処理中止
for enemy in $game_troop.enemies
return if enemy.exist?
end
@battle_end = true
end
end
#--------------------------------------------------------------------------
# ● ターン終了
#--------------------------------------------------------------------------
def turn_end
# 全バトラーの状態をチェック
for battler in $game_troop.enemies + $game_party.actors
# 防御中のアクションをクリア(ATBは性質上ここではクリアさせない)
battler.current_action.clear if battler.guarding? && @countup == nil
# そのターンのみ有効なステートがある場合、それを解除
for state in battler.states
if $data_states[state].extension.include?("0ターン解除")
battler.remove_state(state)
# ステータスウィンドウをリフレッシュ
@status_window.refresh
end
end
end
end #--------------------------------------------------------------------------
# ● フレーム更新 (メインフェーズステップ 2 : アクション開始) ※再定義
#--------------------------------------------------------------------------
def update_phase4_step2
# アニメーション再生中にCTをカウントするか(ATB用)
if @countup != nil
@countup = PARA_CTB::ANIMATION_WAIT ? false : true
end
# 強制アクションでなければ
unless @active_battler.current_action.forcing
# 制約が [敵を通常攻撃する] か [味方を通常攻撃する] の場合
if @active_battler.restriction == 2 or @active_battler.restriction == 3
# アクションに攻撃を設定
@active_battler.current_action.kind = 0
@active_battler.current_action.basic = 0
end
# 制約が [行動できない] の場合
if @active_battler.restriction == 4
# CTをクリア(ATB用)
clear_ct(@active_battler) if @countup != nil
# アクション強制対象のバトラーをクリア
$game_temp.forcing_battler = nil
# バトラーのアクティブ化を解除
@active_battler.active = false
# ステップ 1 に移行
return @phase4_step = 1
end
end
# 対象バトラーをクリア
@target_battlers = []
# バトラーをアクティブ化
@active_battler.active = true
# アクションの種別で分岐
case @active_battler.current_action.kind
when 0 # 基本
kind = @active_battler.current_action.basic
execute_action_attack if kind == 0
execute_action_guard if kind == 1
execute_action_escape if kind == 2
execute_action_none if kind == 3
when 1 # スキル
execute_action_skill
when 2 # アイテム
execute_action_item
end
# 複数回行動のエネミーがいる場合、次の行動を決定
if !@active_battler.actor? && @active_battler.act_time != 0
@active_battler.make_action
@active_battler.act_time -= 1
end
# ステップ6へ(スキル派生+ATBの場合は除く)
update_phase4_step6 unless @phase4_step == "derivation"
# バトラーのアクティブ化を解除
@active_battler.active = false
# スキル派生+ATBの場合ステップ1へ
@phase4_step = 1 if @phase4_step == "derivation"
end
#--------------------------------------------------------------------------
# ● 戦闘行動の実行 : 攻撃
#--------------------------------------------------------------------------
def execute_action_attack
# 行動中に死なないようメンバー全員を不死身化
immortaling
# 行動側バトラーがエネミーの場合
if @active_battler.is_a?(Game_Enemy)
if @active_battler.restriction == 3
target = $game_troop.random_target_enemy
elsif @active_battler.restriction == 2
target = $game_party.random_target_actor
else
index = @active_battler.current_action.target_index
target = $game_party.smooth_target_actor(index)
end
end
# 行動側バトラーがアクターの場合
if @active_battler.is_a?(Game_Actor)
if @active_battler.restriction == 3
target = $game_party.random_target_actor
elsif @active_battler.restriction == 2
target = $game_troop.random_target_enemy
else
index = @active_battler.current_action.target_index
target = $game_troop.smooth_target_enemy(index)
end
end
# 対象側バトラーの配列を設定
@target_battlers = [target]
target_decision
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?, @active_battler.index, action)
playing_action
end
#--------------------------------------------------------------------------
# ● 戦闘行動の実行 : 防御
#--------------------------------------------------------------------------
def execute_action_guard
@help_window.set_text("防御", 1)
@help_window.visible = true
@active_battler.blink = true
@spriteset.set_action(@active_battler.actor?, @active_battler.index, @active_battler.defence)
wait(20)
@active_battler.blink = false
@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.escape
$game_system.se_play($data_system.escape_se)
wait(20)
@help_window.visible = false
end
#--------------------------------------------------------------------------
# ● 戦闘行動の実行 : 行動なし
#--------------------------------------------------------------------------
def execute_action_none
# CTをクリア(ATB用)
clear_ct(@active_battler) if @countup != nil
$game_temp.forcing_battler = nil
@phase4_step = 1
end
#--------------------------------------------------------------------------
# ● 戦闘行動の実行 : スキル
#--------------------------------------------------------------------------
def execute_action_skill
skill = $data_skills[@active_battler.current_action.skill_id]
# スキル使用判定
return break_action("skill") unless @active_battler.skill_can_use?(skill.id)
# 行動中に死なないようメンバー全員を不死身化
immortaling
# ターゲットの決定
target_decision(skill)
# バトラーアクション実行
@spriteset.set_action(@active_battler.actor?, @active_battler.index, skill.base_action)
# ヘルプにスキル名表示
@help_window.set_text(skill.name, 1) unless skill.extension.include?("ヘルプ非表示")
# コスト消費
@active_battler.consum_skill_cost(skill)
# アクションタイム
playing_action
# コモンイベント取得
@common_event_id = skill.common_event_id
end
#--------------------------------------------------------------------------
# ● 戦闘行動の実行 : アイテム
#--------------------------------------------------------------------------
def execute_action_item
item = $data_items[@active_battler.current_action.item_id]
return break_action("item") unless $game_party.item_can_use?(item.id)
immortaling
target_decision(item)
@spriteset.set_action(@active_battler.actor?, @active_battler.index, item.base_action)
@help_window.set_text(item.name, 1) unless item.extension.include?("ヘルプ非表示")
$game_party.lose_item(@item.id, 1) if @item.consumable
playing_action
@common_event_id = item.common_event_id
end
#--------------------------------------------------------------------------
# ● 行動中断
#--------------------------------------------------------------------------
def break_action(obj)
# アクション強制対象のバトラーをクリア
$game_temp.forcing_battler = nil
# CTをクリア(ATB用)
declease_ct(@active_battler,100-PARA_CTB::ACT_SKILL_CT) if obj == "skill" && @countup != nil
declease_ct(@active_battler,100-PARA_CTB::ACT_SKILL_CT) if obj == "item" && @countup != nil
end
#--------------------------------------------------------------------------
# ● ターゲット決定
#--------------------------------------------------------------------------
def target_decision(obj = nil)
# スキル、アイテムのターゲット範囲拡張
if obj != nil
set_target_battlers(obj.scope)
if obj.extension.include?("全域")
@target_battlers = []
# 戦闘不能用のターゲットで区別
if obj.scope != 5 or obj.scope != 6
for target in $game_troop.enemies + $game_party.actors
@target_battlers.push(target) if target.exist?
end
else
for target in $game_troop.enemies + $game_party.actors
@target_battlers.push(target) if target != nil && target.hp0?
end
end
end
@target_battlers.delete(@active_battler) if obj.extension.include?("自分以外")
# ランダムターゲットの場合、一体を選択しランダム範囲を保持
if obj.extension.include?("ランダムターゲット")
randum_targets = @target_battlers.dup
@target_battlers = [randum_targets[rand(randum_targets.size)]]
end
end
# ターゲットがいない場合、アクション中断
if @target_battlers.size == 0
action = @active_battler.recover_action
@spriteset.set_action(@active_battler.actor?, @active_battler.index, action)
end
@spriteset.set_target(@active_battler.actor?, @active_battler.index, @target_battlers)
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 action_end
elsif action == "終了"
break action_end
elsif action[0] == "対象アニメ"
damage_action(action[1])
end
end
end
#--------------------------------------------------------------------------
# ● 個別処理
#--------------------------------------------------------------------------
def individual
# ターゲット情報を保持
@individual_target = @target_battlers
@stand_by_target = @target_battlers.dup
end
#--------------------------------------------------------------------------
# ● コラプス禁止
#--------------------------------------------------------------------------
def immortaling
# 全員に不死身付与
for member in $game_party.actors + $game_troop.enemies
# 既に戦闘不能ならスキップ
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.actors + $game_troop.enemies
next if member.dead?
next if member.non_dead
member.immortal = false
member.add_state(1) if member.hp == 0
member.perform_collapse
end
# この時点で待機アクションに即反映させる
@target_battlers = @stand_by_target if @stand_by_target != nil
return if @target_battlers == nil or @target_battlers.size == 0
for target in @target_battlers
@spriteset.set_stand_by_action(target.actor?, target.index)
# 自動復活チェック
next unless target.hp == 0
resurrection(target)
end
# ステータスウインドウをリフレッシュ
@status_window.refresh
end
#--------------------------------------------------------------------------
# ● 自動復活
#--------------------------------------------------------------------------
def resurrection(target)
for state in target.states
for ext in $data_states[state].extension
name = ext.split('')
next unless name[0] == "自"
name = name.join
name.slice!("自動復活/")
target.hp = target.maxhp * name.to_i / 100
target.remove_state(1)
target.remove_state(state)
target.animation_id = N01::RESURRECTION
target.animation_hit = true
@status_window.refresh
end
end
end #--------------------------------------------------------------------------
# ● 魔法反射・無効
#--------------------------------------------------------------------------
def magic_reflection(target)
return unless $data_skills[@active_battler.current_action.skill_id].int_f != 0
for state in target.states
for ext in $data_states[state].extension
name = ext.split('')
next unless name[0] == "魔"
if name[2] == "反"
name = name.join
name.slice!("魔法反射/")
target.animation_id = name.to_i
target.animation_hit = true
@reflection = true
else
name = name.join
name.slice!("魔法無効/")
target.animation_id = name.to_i
target.animation_hit = true
@invalid = true
end
end
end
end
#--------------------------------------------------------------------------
# ● 物理反射・無効
#--------------------------------------------------------------------------
def physics_reflection(target)
return unless $data_skills[@active_battler.current_action.skill_id].str_f != 0
for state in target.states
for ext in $data_states[state].extension
name = ext.split('')
next unless name[0] == "物"
if name[2] == "反"
name = name.join
name.slice!("物理反射/")
target.animation_id = name.to_i
target.animation_hit = true
@reflection = true
else
name = name.join
name.slice!("物理無効/")
target.animation_id = name.to_i
target.animation_hit = true
@invalid = true
end
end
end
end
#--------------------------------------------------------------------------
# ● スキルコスト吸収
#--------------------------------------------------------------------------
def absorb_cost(target)
for state in target.states
if $data_states[state].extension.include?("コスト吸収")
skill = $data_skills[@active_battler.current_action.skill_id]
cost = @active_battler.make_skill_cost(@active_battler, skill)
# SP消費とHP消費で分ける
return target.hp += cost if skill.extension.include?("HP消費")
return target.sp += cost
end
end
end

复制代码

没完,还有很长很长= =...................

遠夜 · 发表于 2009-2-13 07:35:02

继续很长的第3个T T

#--------------------------------------------------------------------------
# ● アクション終了
#--------------------------------------------------------------------------
def action_end
# 初期化
@individual_target = nil
@help_window.visible = false if @help_window != nil && @help_window.visible
# 念のため不死身化解除
unimmortaling
for member in $game_troop.enemies
member.non_dead = false if member.non_dead
end
# スキル反射されていた場合
if @active_battler.reflex != nil
obj = $data_skills[@active_battler.current_action.skill_id]
@active_battler.perfect_skill_effect(@active_battler, obj)
pop_damage(@active_battler, obj, @active_battler.reflex)
if @active_battler.dead?
update_effect_wait
@active_battler.perform_collapse
wait(40)
end
@active_battler.reflex = nil
end
# スキル派生がある場合、行動続行
if @active_battler.derivation != 0
@active_battler.current_action.skill_id = @active_battler.derivation
@active_battler.current_action.kind = 1
@active_battler.derivation = 0
@action_battlers.unshift(@active_battler)
derivate_action if @countup != nil
else
# 次の行動までウエイトを挟む
wait(N01::ACTION_WAIT)
@spriteset.set_stand_by_action(@active_battler.actor?, @active_battler.index)
end
end
#--------------------------------------------------------------------------
# ● スキル派生(ATB用)
#--------------------------------------------------------------------------
def derivate_action
# アクション強制対象のバトラーをクリア
$game_temp.forcing_battler = nil
# コモンイベント ID が有効の場合
if @common_event_id > 0
# イベントをセットアップ
common_event = $data_common_events[@common_event_id]
$game_system.battle_interpreter.setup(common_event.list, 0)
end
# ステップ6に移行させないフラグを立てる
@phase4_step = "derivation"
end
#--------------------------------------------------------------------------
# ● ダメージ処理
#--------------------------------------------------------------------------
def damage_action(action)
# 個別処理の場合ターゲットを一つずつ抜き出す
@target_battlers = [@individual_target.shift] if @active_battler.individual
# スキル時
if @active_battler.current_action.kind == 1
obj = $data_skills[@active_battler.current_action.skill_id]
for target in @target_battlers
return if target == nil
# HPが0なら戦闘不能復活以外はミスしない
if obj.scope == 5 or obj.scope == 6
return unless target.dead?
else
return if target.dead?
end
if target.hp == 0 && obj.scope != 5 && obj.scope != 6
target.perfect_skill_effect(@active_battler, obj)
elsif obj.extension.include?("必中")
target.perfect_skill_effect(@active_battler, obj)
else
magic_reflection(target) unless obj.extension.include?("反射無視")
physics_reflection(target) unless obj.extension.include?("反射無視")
target.skill_effect(@active_battler, obj) unless @reflection or @invalid
end
pop_damage(target, obj, action) unless @reflection or @invalid
absorb_cost(target)
@active_battler.reflex = action if @reflection
@reflection = false
@invalid = false
target.movable_backup = target.movable? if @countup != nil
end
# アイテム時
elsif @active_battler.current_action.kind == 2
obj = $data_items[@active_battler.current_action.item_id]
for target in @target_battlers
return if target == nil
if obj.scope == 5 or obj.scope == 6
return unless target.dead?
else
return if target.dead?
end
target.revival = true if obj.scope == 5 or obj.scope == 6
target.item_effect(obj)
pop_damage(target, obj, action)
target.movable_backup = target.movable? if @countup != nil
end
# 通常攻撃時
else
for target in @target_battlers
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)
target.movable_backup = target.movable? if @countup != nil
end
end
# 連続行動中のランダムターゲットを考慮し、すぐに次のターゲットを選択
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 && obj.extension.size != 0
# 吸収攻撃
absorb_attack(obj, target, index, actor)
# ダメージアクション禁止
action[2] = false if obj.extension.include?("ダメージアクション禁止")
end
# 対象のリアクション
@spriteset.set_damage_action(target.actor?, target.index, action)
# ステータスウインドウをリフレッシュ
@status_window.refresh
end
end
#==============================================================================
# ■ Spriteset_Battle
#------------------------------------------------------------------------------
# 　バトル画面のスプライトをまとめたクラスです。
#==============================================================================
class Spriteset_Battle
#--------------------------------------------------------------------------
# ● オブジェクト初期化
#--------------------------------------------------------------------------
alias initialize_n01 initialize
def initialize
initialize_n01
# スプライトを一旦解放
for sprite in @enemy_sprites + @actor_sprites
sprite.dispose
end
# バックアタック判定
back_attack if N01::BACK_ATTACK
# スプライトの作成
create_enemies
create_actors
# フレーム更新
update
end
#--------------------------------------------------------------------------
# ● エネミースプライトの作成
#--------------------------------------------------------------------------
def create_enemies
@enemy_sprites = []
for i in 0...$game_troop.enemies.size
enemy = $game_troop.enemies[i]
@enemy_sprites.push(Sprite_Battler.new(@viewport1, enemy))
# バトル開始アクションを起こす
@enemy_sprites[i].opacity = 0 if $game_troop.enemies[i].hidden
@enemy_sprites[i].first_action if $game_troop.enemies[i] != nil
end
end
#--------------------------------------------------------------------------
# ● アクタースプライトの作成
#--------------------------------------------------------------------------
def create_actors
@actor_sprites = []
# メンバー最大数スプライトを用意
member = N01::MAX_MEMBER
for i in 0...member
actor = $game_party.actors[i]
@actor_sprites.push(Sprite_Battler.new(@viewport1, actor))
@actor_sprites[i].first_action if $game_party.actors[i] != nil
end
end
#--------------------------------------------------------------------------
# ● バックアタック　
#--------------------------------------------------------------------------
def back_attack
# 強制バックアタックならフラグON
for i in 0...N01::BACK_ATTACK_SWITCH.size
return $back_attack = true if $game_switches[N01::BACK_ATTACK_SWITCH[i]]
end
# イベントバックアタック回避がONなら
return $back_attack = false if $back_attack == "boss"
# バックアタック無効化スイッチをチェック
for i in 0...N01::NON_BACK_ATTACK_SWITCH.size
return $back_attack = false if $game_switches[N01::NON_BACK_ATTACK_SWITCH[i]]
end
# 装備等によるバックアタック無効化をチェック
for actor in $game_party.actors
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
# エネミーの素早さ平均値を計算
enemies_agi = 0
for enemy in $game_troop.enemies
enemies_agi += enemy.agi
end
enemies_agi /= $game_troop.enemies.size if $game_troop.enemies.size != 0
# アクターの素早さ平均値を計算
actors_agi = 0
for actor in $game_party.actors
actors_agi += actor.agi
end
actors_agi /= $game_party.actors.size if $game_party.actors.size != 0
# バックアタック判定
$back_attack = rand(100) < N01::BACK_ATTACK_RATE * enemies_agi / actors_agi if actors_agi != 0
@battleback_sprite.mirror = true if $back_attack && N01::BACK_ATTACK_MIRROR
end
#--------------------------------------------------------------------------
# ● フレーム更新 ※再定義
#--------------------------------------------------------------------------
def update
# アクタースプライトの内容を更新 (アクターの入れ替えに対応)
for i in 0...$game_party.actors.size
@actor_sprites[i].battler = $game_party.actors[i]
end
# バトルバックのファイル名が現在のものと違う場合
if @battleback_name != $game_temp.battleback_name
@battleback_name = $game_temp.battleback_name
@battleback_sprite.bitmap.dispose if @battleback_sprite.bitmap != nil
@battleback_sprite.bitmap = RPG::Cache.battleback(@battleback_name)
@battleback_sprite.src_rect.set(0, 0, 640, 320)
end
# バトラースプライトを更新
for sprite in @enemy_sprites + @actor_sprites
sprite.update
end
# 天候グラフィックを更新
@weather.type = $game_screen.weather_type
@weather.max = $game_screen.weather_max
@weather.update
# ピクチャスプライトを更新
for sprite in @picture_sprites
sprite.update
end
# タイマースプライトを更新
@timer_sprite.update
# 画面の色調とシェイク位置を設定
@viewport1.tone = $game_screen.tone
@viewport1.ox = $game_screen.shake
# 画面のフラッシュ色を設定
@viewport4.color = $game_screen.flash_color
# ビューポートを更新
@viewport1.update
@viewport2.update
@viewport4.update
end
#--------------------------------------------------------------------------
# ● ATB判別　
#--------------------------------------------------------------------------
def set_atb
for sprite in @enemy_sprites + @actor_sprites
sprite.set_atb
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_stand_by_action(actor, index)
@actor_sprites[index].push_stand_by if actor
@enemy_sprites[index].push_stand_by unless actor
end
end
#==============================================================================
# ■ Sprite_MoveAnime
#------------------------------------------------------------------------------
# 　アニメ飛ばし用のスプライトです。
#==============================================================================
class Sprite_MoveAnime < RPG::Sprite
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
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,weapon_name,loop)
# 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
# 武器グラフィックを表示
self.bitmap = RPG::Cache.icon(weapon_name)
self.ox = self.bitmap.width / 2
self.oy = self.bitmap.height / 2
self.visible = true
# バトラーより手前に表示
self.z = 1000
end
# 最初は動かさず一回だけ表示
self.x = @base_x + @move_x
self.y = @base_y + @move_y + @orbit
if id != 0 && !loop
animation($data_animations[id],true)
elsif id != 0 && loop
loop_animation($data_animations[id])
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
animation(nil,false)
loop_animation(nil)
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 < RPG::Sprite
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
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フレーム当たりの縦拡大率
@weapon_width = 0 # 武器の横幅
@weapon_height = 0 # 武器の縦幅
@freeze = -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
if @battler.actor?
weapon = $data_weapons[@battler.weapon_id]
else
weapon = $data_weapons[@battler.weapon]
# エネミー反転フラグ確認
@mirroring = true if @battler.action_mirror
end
# 武器がなければ処理をキャンセル
return if weapon == nil
# アイコンを利用するなら
if weapon.graphic == ""
self.bitmap = RPG::Cache.icon(weapon.icon_name)
@weapon_width = @weapon_height = 24
# ID指定があったら、アイコンではなくそのグラフィックを取得
else
self.bitmap = RPG::Cache.icon(weapon.graphic)
@weapon_width = self.bitmap.width
@weapon_height = self.bitmap.height
end
end
#--------------------------------------------------------------------------
# ● アニメ固定時の武器位置を取得
#--------------------------------------------------------------------------
def freeze(action)
@freeze = action
end
#--------------------------------------------------------------------------
# ● 武器アクションを取得 freeze
#--------------------------------------------------------------------------
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
# 固定アニメの場合、この時点で動きを消化
if @freeze != -1
for i in 0..@freeze + 1
@angle += @angling
@zoom_x += @zooming_x
@zoom_y += @zooming_y
# スプライトの座標を更新
@move_x += @moving_x
@move_y += @moving_y
end
@angling = 0
@zooming_x = 0
@zooming_y = 0
@moving_x = 0
@moving_y = 0
end
# 可視
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
@freeze = -1
@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
#==============================================================================
# ■ Scene_Map
#------------------------------------------------------------------------------
# 　マップ画面の処理を行うクラスです。
#==============================================================================
class Scene_Map
#--------------------------------------------------------------------------
# ● バトルの呼び出し (イベント戦闘でバックアタックを無効化する)
#--------------------------------------------------------------------------
alias call_battle_n01 call_battle
def call_battle
call_battle_n01
$back_attack = "boss" unless N01::EVENT_BACK_ATTACK
end
end
#==============================================================================
# ■ Game_Battler (分割定義 1)
#------------------------------------------------------------------------------
# 　バトラーを扱うクラスです。
#==============================================================================
class Game_Battler
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
attr_accessor :sp_damage # 行動結果: SP ダメージ
attr_accessor :collapse # 崩壊フラグ
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 # 個別処理
attr_accessor :play # アクション情報
attr_accessor :force_action # 強制されるアクション情報
attr_accessor :force_target # ターゲット変更情報
attr_accessor :revival # 復活
attr_accessor :reflex # スキル反射情報
attr_accessor :absorb # スキルコスト吸収
attr_accessor :battler_height # バトラー画像の縦幅
attr_accessor :anime_mirror # 戦闘アニメの反転フラグ
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 = @act_time = 0
@force_action = @force_target = @base_position_x = @base_position_y = 0
@absorb = @play = @battler_height = 0
@active = @non_dead = @individual = @slip_damage = @revival = false
@collapse = @sp_damage = @anime_mirror = false
end
#--------------------------------------------------------------------------
# ● 一番新しいステートIDを返す
#--------------------------------------------------------------------------
def state_id
return @states[@states.size - 1]
end
#--------------------------------------------------------------------------
# ● スキルの使用可能判定 ※再定義
#--------------------------------------------------------------------------
def skill_can_use?(skill_id)
skill = $data_skills[skill_id]
cost = make_skill_cost(self, skill)
# HP消費かSP消費かで分岐
if skill.extension.include?("HP消費")
return false if cost >= self.hp
else
return false if cost > self.sp
end
# 戦闘不能の場合は使用不可
return false if dead?
# 沈黙状態の場合、物理スキル以外は使用不可
return false if skill.atk_f == 0 and self.restriction == 1
# 使用可能時を取得
occasion = skill.occasion
# 戦闘中の場合 [常時] または [バトルのみ] なら使用可
return (occasion == 0 or occasion == 1) if $game_temp.in_battle
# 戦闘中ではない場合 [常時] または [メニューのみ] なら使用可
return (occasion == 0 or occasion == 2)
end
#--------------------------------------------------------------------------
# ● スキルコスト計算
#--------------------------------------------------------------------------
def make_skill_cost(user, skill)
cost = skill.sp_cost
if skill.extension.include?("%コストMAX")
return user.maxhp * cost / 100 if skill.extension.include?("HP消費")
return user.maxsp * cost / 100
elsif skill.extension.include?("%コストNOW")
return user.hp * cost / 100 if skill.extension.include?("HP消費")
return user.sp * cost / 100
end
return cost
end
#--------------------------------------------------------------------------
# ● スキルコスト消費
#--------------------------------------------------------------------------
def consum_skill_cost(skill)
cost = make_skill_cost(self, skill)
return self.hp -= cost if skill.extension.include?("HP消費")
return self.sp -= cost
end
#--------------------------------------------------------------------------
# ● スキルの効果適用
#--------------------------------------------------------------------------
alias skill_effect_n01 skill_effect
def skill_effect(user, skill)
# ダメージ計算
now_hp = self.hp
# スキルの効果範囲が HP 1 以上の味方で、自分の HP が 0、
# またはスキルの効果範囲が HP 0 の味方で、自分の HP が 1 以上の場合
if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or
((skill.scope == 5 or skill.scope == 6) and self.hp >= 1)
# メソッド終了
return false
end
effective = skill_effect_n01(user, skill)
# 効果がなければ処理中断
return if effective == false
# 拡張設定チェック
check_extension(skill)
# 割合ダメージ
if @ratio_maxdamage != nil
self.damage = self.maxhp * @ratio_maxdamage / 100 unless @sp_damage
self.damage = self.maxsp * @ratio_maxdamage / 100 if @sp_damage
end
if @ratio_nowdamage != nil
self.damage = self.hp * @ratio_nowdamage / 100 unless @sp_damage
self.damage = self.sp * @ratio_nowdamage / 100 if @sp_damage
end
# コスト威力
if @cost_damage
cost = make_skill_cost(user, skill)
if skill.extension.include?("HP消費")
self.damage = self.damage * cost / user.maxhp
else
self.damage = self.damage * cost / user.maxsp
end
end
# 現在HP威力
self.damage = self.damage * user.hp / user.maxhp if @nowhp_damage
# 現在SP威力
self.damage = self.damage * user.sp / user.maxsp if @nowsp_damage
# 拡張反映
if @sp_damage
self.hp = now_hp
self.sp -= self.damage
elsif @extension
self.hp = now_hp
self.hp -= self.damage
end
return true
end

复制代码

遠夜 · 发表于 2009-2-13 07:35:45

最后一部分:

#--------------------------------------------------------------------------
# ● 拡張設定チェック
#--------------------------------------------------------------------------
def check_extension(skill)
# 初期化
@extension = false
@sp_damage = false
@cost_damage = false
@nowhp_damage = false
@nowsp_damage = false
@ratio_maxdamage = nil
@ratio_nowdamage = nil
for ext in skill.extension
break if self.damage == "Miss" or self.damage == "" or self.damage == 0
# SPダメージ
if ext == "SPダメージ"
next @sp_damage = true
# コスト威力
elsif ext == "コスト威力"
@extension = true
next @cost_damage = true
# 現在HP威力
elsif ext == "現HP威力"
@extension = true
next @nowhp_damage = true
# 現在SP威力
elsif ext == "現SP威力"
@extension = true
next @nowsp_damage = true
else
# 割合ダメージ
name = ext.split('')
if name[5] == "M"
name = name.join
name.slice!("%ダメージMAX/")
@extension = true
next @ratio_maxdamage = name.to_i
elsif name[5] == "N"
name = name.join
name.slice!("%ダメージNOW/")
@extension = true
next @ratio_nowdamage = name.to_i
end
end
end
end
#--------------------------------------------------------------------------
# ● 通常攻撃の効果適用絶対に回避できない処理
#--------------------------------------------------------------------------
def perfect_attack_effect(attacker)
# クリティカルフラグをクリア
self.critical = false
# 基本ダメージを計算
atk = [attacker.atk - self.pdef / 2, 0].max
self.damage = atk * (20 + attacker.str) / 20
# 属性修正
self.damage *= elements_correct(attacker.element_set)
self.damage /= 100
# ダメージの符号が正の場合
if self.damage > 0
# クリティカル修正
if rand(100) < 4 * attacker.dex / self.agi
self.damage *= 2
self.critical = true
end
# 防御修正
self.damage /= 2 if self.guarding?
end
# 分散
if self.damage.abs > 0
amp = [self.damage.abs * 15 / 100, 1].max
self.damage += rand(amp+1) + rand(amp+1) - amp
end
# ステート衝撃解除
remove_states_shock
# HP からダメージを減算
self.hp -= self.damage
# ステート変化
@state_changed = false
states_plus(attacker.plus_state_set)
states_minus(attacker.minus_state_set)
# メソッド終了
return true
end
#--------------------------------------------------------------------------
# ● スキルの効果適用絶対に回避できない処理
#--------------------------------------------------------------------------
def perfect_skill_effect(user, skill)
# クリティカルフラグをクリア
self.critical = false
# スキルの効果範囲が HP 1 以上の味方で、自分の HP が 0、
# またはスキルの効果範囲が HP 0 の味方で、自分の HP が 1 以上の場合
if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or
((skill.scope == 5 or skill.scope == 6) and self.hp >= 1)
# メソッド終了
return false
end
# 有効フラグをクリア
effective = false
# コモンイベント ID が有効の場合は有効フラグをセット
effective |= skill.common_event_id > 0
# 威力を計算
power = skill.power + user.atk * skill.atk_f / 100
if power > 0
power -= self.pdef * skill.pdef_f / 200
power -= self.mdef * skill.mdef_f / 200
power = [power, 0].max
end
# 倍率を計算
rate = 20
rate += (user.str * skill.str_f / 100)
rate += (user.dex * skill.dex_f / 100)
rate += (user.agi * skill.agi_f / 100)
rate += (user.int * skill.int_f / 100)
# 基本ダメージを計算
self.damage = power * rate / 20
# 属性修正
self.damage *= elements_correct(skill.element_set)
self.damage /= 100
# ダメージの符号が正の場合防御修正
self.damage /= 2 if self.damage > 0 && self.guarding?
# 分散
if skill.variance > 0 and self.damage.abs > 0
amp = [self.damage.abs * skill.variance / 100, 1].max
self.damage += rand(amp+1) + rand(amp+1) - amp
end
# 威力 0 以外の物理攻撃の場合
if skill.power != 0 and skill.atk_f > 0
# ステート衝撃解除
remove_states_shock
# 有効フラグをセット
effective = true
end
# HP からダメージを減算
last_hp = self.hp
self.hp -= self.damage
effective |= self.hp != last_hp
# ステート変化
@state_changed = false
effective |= states_plus(skill.plus_state_set)
effective |= states_minus(skill.minus_state_set)
# 威力が 0 の場合ダメージに空文字列を設定
self.damage = "" if skill.power == 0
# メソッド終了
return effective
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
end
#==============================================================================
# ■ Game_Actor
#------------------------------------------------------------------------------
# 　アクターを扱うクラスです。
#==============================================================================
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# ● アクターか否かの判定
#--------------------------------------------------------------------------
def actor?
return true
end
#--------------------------------------------------------------------------
# ● IDによるスキルの習得済み判定
#--------------------------------------------------------------------------
def skill_id_learn?(skill_id)
return @skills.include?(skill_id)
end
#--------------------------------------------------------------------------
# ● スキルの使用可能判定 ※再定義
#--------------------------------------------------------------------------
def skill_can_use?(skill_id)
return super
end
#--------------------------------------------------------------------------
# ● グラフィックの変更
#--------------------------------------------------------------------------
def graphic_change(character_name)
@character_name = character_name
end
#--------------------------------------------------------------------------
# ● コラプスの実行
#--------------------------------------------------------------------------
def perform_collapse
$game_system.se_play($data_system.actor_collapse_se) 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 = 640 - 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
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
attr_accessor :adj_speed # 複数回行動の速度補正
attr_accessor :act_time # 行動数回
#--------------------------------------------------------------------------
# ● アクターか否かの判定
#--------------------------------------------------------------------------
def actor?
return false
end
#--------------------------------------------------------------------------
# ● アクションスピードの決定複数回行動用
#--------------------------------------------------------------------------
def make_action_speed2(adj)
@adj_speed = @current_action.speed if @adj_speed == nil
@adj_speed = @adj_speed * adj / 100
end
#--------------------------------------------------------------------------
# ● コラプスの実行
#--------------------------------------------------------------------------
def perform_collapse
@force_action = ["N01collapse"] if $game_temp.in_battle and dead?
end
#--------------------------------------------------------------------------
# ● 初期配置の取得
#--------------------------------------------------------------------------
def base_position
return if self.index == nil
@base_position_x = self.screen_x + self.position_plus[0]
@base_position_y = self.screen_y + self.position_plus[1]
# バックアタック時はX軸を逆に
@base_position_x = 640 - self.screen_x - self.position_plus[0] if $back_attack
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
#==============================================================================
# ■ Arrow_Enemy
#------------------------------------------------------------------------------
# 　エネミーを選択させるためのアローカーソルです。
#==============================================================================
class Arrow_Enemy < Arrow_Base
#--------------------------------------------------------------------------
# ● フレーム更新
#--------------------------------------------------------------------------
def update
super
# 存在しないエネミーを指していたら飛ばす
$game_troop.enemies.size.times do
break if self.enemy.exist?
@index += 1
@index %= $game_troop.enemies.size
end
# カーソル右
next_cursor if Input.repeat?(Input::LEFT) && !$back_attack
back_cursor if Input.repeat?(Input::LEFT) && $back_attack
# カーソル左
back_cursor if Input.repeat?(Input::RIGHT) && !$back_attack
next_cursor if Input.repeat?(Input::RIGHT) && $back_attack
# カーソル下
next_cursor if Input.repeat?(Input::UP)
# カーソル上
back_cursor if Input.repeat?(Input::DOWN)
# スプライトの座標を設定
if self.enemy != nil
self.x = self.enemy.position_x + N01::ENEMY_CURSOR[0]
self.y = self.enemy.position_y + N01::ENEMY_CURSOR[1]
end
end
#--------------------------------------------------------------------------
# ● カーソルを次に進める
#--------------------------------------------------------------------------
def next_cursor
$game_system.se_play($data_system.cursor_se)
$game_troop.enemies.size.times do
@index += 1
@index %= $game_troop.enemies.size
break if self.enemy.exist?
end
end
#--------------------------------------------------------------------------
# ● カーソルを前に戻す
#--------------------------------------------------------------------------
def back_cursor
$game_system.se_play($data_system.cursor_se)
$game_troop.enemies.size.times do
@index += $game_troop.enemies.size - 1
@index %= $game_troop.enemies.size
break if self.enemy.exist?
end
end
end
#==============================================================================
# ■ Arrow_Actor
#------------------------------------------------------------------------------
# 　アクターを選択させるためのアローカーソルです。
#==============================================================================
class Arrow_Actor < Arrow_Base
#--------------------------------------------------------------------------
# ● フレーム更新
#--------------------------------------------------------------------------
def update
super
# カーソル右
next_cursor if Input.repeat?(Input::RIGHT) && !$back_attack
back_cursor if Input.repeat?(Input::RIGHT) && $back_attack
# カーソル左
back_cursor if Input.repeat?(Input::LEFT) && !$back_attack
next_cursor if Input.repeat?(Input::LEFT) && $back_attack
# カーソル下
next_cursor if Input.repeat?(Input::DOWN)
# カーソル上
back_cursor if Input.repeat?(Input::UP)
# スプライトの座標を設定
if self.actor != nil
self.x = self.actor.position_x + N01::ACTOR_CURSOR[0]
self.y = self.actor.position_y + N01::ACTOR_CURSOR[1]
end
end
#--------------------------------------------------------------------------
# ● カーソルを次に進める
#--------------------------------------------------------------------------
def next_cursor
$game_system.se_play($data_system.cursor_se)
@index += 1
@index %= $game_party.actors.size
end
#--------------------------------------------------------------------------
# ● カーソルを前に戻す
#--------------------------------------------------------------------------
def back_cursor
$game_system.se_play($data_system.cursor_se)
@index += $game_party.actors.size - 1
@index %= $game_party.actors.size
end
end
#==============================================================================
# ■ Window_Base
#------------------------------------------------------------------------------
# 　ゲーム中のすべてのウィンドウのスーパークラスです。
#==============================================================================
class Window_Base < Window
#--------------------------------------------------------------------------
# ● ステートの描画 ※再定義
#--------------------------------------------------------------------------
def draw_actor_state(actor, x, y, width = 120)
text = make_battler_state_text(actor, width, true)
self.contents.font.color = actor.dead? ? knockout_color : normal_color
self.contents.draw_text(x, y, width, 32, text)
end
end
#==============================================================================
# ■ Window_Skill
#------------------------------------------------------------------------------
# 　スキル画面、バトル画面で、使用できるスキルの一覧を表示するウィンドウです。
#==============================================================================
class Window_Skill < Window_Selectable
#--------------------------------------------------------------------------
# ● 項目の描画 ※再定義
#--------------------------------------------------------------------------
def draw_item(index)
skill = @data[index]
if @actor.skill_can_use?(skill.id)
self.contents.font.color = normal_color
else
self.contents.font.color = disabled_color
end
x = 4 + index % 2 * (288 + 32)
y = index / 2 * 32
rect = Rect.new(x, y, self.width / @column_max - 32, 32)
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
bitmap = RPG::Cache.icon(skill.icon_name)
opacity = self.contents.font.color == normal_color ? 255 : 128
self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
self.contents.draw_text(x + 28, y, 204, 32, skill.name, 0)
cost = @actor.make_skill_cost(@actor, skill)
self.contents.draw_text(x + 232, y, 48, 32, cost.to_s, 2)
end
end
#==============================================================================
# ■ Window_Base
#------------------------------------------------------------------------------
# 　スプライトモジュールの再定義
#==============================================================================
module RPG
class Sprite < ::Sprite
# エフェクト処理を無効化
def whiten
end
def appear
end
def escape
end
def collapse
end
# SPダメージ用の文字描画
def damage(value, critical)
dispose_damage
if value.is_a?(Numeric)
damage_string = value.abs.to_s
else
damage_string = value.to_s
end
bitmap = Bitmap.new(160, 48)
bitmap.font.name = "Arial Black"
bitmap.font.size = 32
bitmap.font.color.set(0, 0, 0)
bitmap.draw_text(-1, 12-1, 160, 36, damage_string, 1)
bitmap.draw_text(+1, 12-1, 160, 36, damage_string, 1)
bitmap.draw_text(-1, 12+1, 160, 36, damage_string, 1)
bitmap.draw_text(+1, 12+1, 160, 36, damage_string, 1)
if value.is_a?(Numeric) and value < 0
bitmap.font.color.set(176, 255, 144)
else
bitmap.font.color.set(255, 255, 255)
end
bitmap.draw_text(0, 12, 160, 36, damage_string, 1)
if critical == "sp_damage"
text = "SP DAMAGE"
text = "SP RECOVER" if value.is_a?(Numeric) and value < 0
bitmap.font.size = 20
bitmap.font.color.set(0, 0, 0)
bitmap.draw_text(-1, -1, 160, 20, text, 1)
bitmap.draw_text(+1, -1, 160, 20, text, 1)
bitmap.draw_text(-1, +1, 160, 20, text, 1)
bitmap.draw_text(+1, +1, 160, 20, text, 1)
bitmap.font.color.set(255, 255, 255)
bitmap.font.color.set(176, 255, 144) if value.is_a?(Numeric) and value < 0
bitmap.draw_text(0, 0, 160, 20, text, 1)
elsif critical
bitmap.font.size = 20
bitmap.font.color.set(0, 0, 0)
bitmap.draw_text(-1, -1, 160, 20, "CRITICAL", 1)
bitmap.draw_text(+1, -1, 160, 20, "CRITICAL", 1)
bitmap.draw_text(-1, +1, 160, 20, "CRITICAL", 1)
bitmap.draw_text(+1, +1, 160, 20, "CRITICAL", 1)
bitmap.font.color.set(255, 255, 255)
bitmap.draw_text(0, 0, 160, 20, "CRITICAL", 1)
end
@_damage_sprite = ::Sprite.new(self.viewport)
@_damage_sprite.bitmap = bitmap
@_damage_sprite.ox = 80
@_damage_sprite.oy = 20
@_damage_sprite.x = self.x
@_damage_sprite.y = self.y - self.oy / 2
@_damage_sprite.z = 3000
@_damage_duration = 40
end
# アニメ反転処理
def dispose_animation
if @_animation_sprites != nil
sprite = @_animation_sprites[0]
if sprite != nil
@@_reference_count[sprite.bitmap] -= 1
if @@_reference_count[sprite.bitmap] == 0
sprite.bitmap.dispose
end
end
for sprite in @_animation_sprites
sprite.dispose
end
@_animation_sprites = nil
@_animation = nil
end
@mirror = false
end
def animation_mirror
@mirror = true
end
def animation_set_sprites(sprites, cell_data, position)
for i in 0..15
sprite = sprites[i]
pattern = cell_data[i, 0]
if sprite == nil or pattern == nil or pattern == -1
sprite.visible = false if sprite != nil
next
end
sprite.visible = true
sprite.src_rect.set(pattern % 5 * 192, pattern / 5 * 192, 192, 192)
if position == 3
if self.viewport != nil
sprite.x = self.viewport.rect.width / 2
sprite.y = self.viewport.rect.height - 160
else
sprite.x = 320
sprite.y = 240
end
else
sprite.x = self.x - self.ox + self.src_rect.width / 2
sprite.y = self.y - self.oy + self.src_rect.height / 2
sprite.y -= self.src_rect.height / 4 if position == 0
sprite.y += self.src_rect.height / 4 if position == 2
end
sprite.x += cell_data[i, 1]
sprite.y += cell_data[i, 2]
sprite.z = 2000
sprite.ox = 96
sprite.oy = 96
sprite.zoom_x = cell_data[i, 3] / 100.0
sprite.zoom_y = cell_data[i, 3] / 100.0
sprite.angle = cell_data[i, 4]
sprite.mirror = (cell_data[i, 5] == 1)
if @mirror
if sprite.mirror
sprite.mirror = false
else
sprite.mirror = true
end
end
sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
sprite.blend_type = cell_data[i, 7]
end
end
end
end

复制代码

全部3个脚本贴完了,擦汗....

redant · 发表于 2009-2-13 08:04:45

本论坛可上传rar、txt文件
也可上传工程压缩包

另外全动画好像就是我给的链接 -。-

遠夜 · 发表于 2009-2-13 18:05:52

是吗?我比较笨,看见就一个脚本,本能的就以为不是了,狂汗,
请允许偶仔细研究下....

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