4905 lines
No EOL
209 KiB
Ruby
4905 lines
No EOL
209 KiB
Ruby
#==============================================================================
|
||
# ■ Sideview Ver100
|
||
#------------------------------------------------------------------------------
|
||
# サイドビューバトラーを管理するクラスです。
|
||
#==============================================================================
|
||
class SideView
|
||
#--------------------------------------------------------------------------
|
||
# ● 公開インスタンス変数
|
||
#--------------------------------------------------------------------------
|
||
attr_accessor :x # 画面X座標
|
||
attr_accessor :y # 画面Y座標
|
||
attr_accessor :z # 画面Z座標
|
||
attr_accessor :h # 高さ座標
|
||
attr_accessor :j # ジャンプ座標
|
||
attr_accessor :c # カーブ座標
|
||
attr_accessor :ox # 横原点
|
||
attr_accessor :oy # 縦原点
|
||
attr_accessor :oy_adjust # 縦原点補正
|
||
attr_accessor :angle # 回転角度
|
||
attr_accessor :zoom_x # 横の拡大率
|
||
attr_accessor :zoom_y # 縦の拡大率
|
||
attr_accessor :pattern_w # セル横位置（矩形内）
|
||
attr_accessor :pattern_h # セル縦位置（矩形内）
|
||
attr_accessor :sx # セル横位置（画像全体）
|
||
attr_accessor :sy # セル縦位置（画像全体）
|
||
attr_accessor :pattern_type # セル更新タイプ
|
||
attr_accessor :pattern_time # セル更新間隔
|
||
attr_accessor :graphic_name # バトラー画像ファイル名
|
||
attr_accessor :graphic_file_index # バトラー画像ファイル名インデックス
|
||
attr_accessor :graphic_index # バトラー画像インデックス
|
||
attr_accessor :cw # セル横矩形
|
||
attr_accessor :ch # セル縦矩形
|
||
attr_accessor :shadow_visible # 影表示
|
||
attr_accessor :weapon_visible # 武器表示
|
||
|
||
attr_accessor :wait # 次の動作待ち時間
|
||
attr_accessor :weapon_index # 表示中の武器画像インデックス配列
|
||
attr_accessor :weapon_end # 武器アニメ終了フラグ
|
||
attr_accessor :force_action # 強制アクション
|
||
attr_accessor :target_battler # ターゲットバトラー情報
|
||
attr_accessor :second_targets # セカンドターゲット情報
|
||
attr_accessor :m_a_targets # アニメ飛ばしターゲット情報
|
||
attr_accessor :individual_targets # 個別処理ターゲットバトラー情報
|
||
attr_accessor :effect_data # エフェクトデータ
|
||
attr_accessor :anime_id # アニメID配列
|
||
attr_accessor :anime_move_id # 飛ばしアニメID配列
|
||
attr_accessor :mirror # 反転フラグ
|
||
attr_accessor :opacity # 透明度
|
||
attr_accessor :opacity_data # 透明度操作情報
|
||
attr_accessor :set_damage # バトルシーンでのダメージ処理
|
||
attr_accessor :m_a_data # アニメ飛ばし情報
|
||
attr_accessor :m_a_starter # アニメ飛ばし開始ターゲット情報
|
||
attr_accessor :action_end # バトルシーンでの行動終了
|
||
attr_accessor :damage_anime_data # ダメージ戦闘アニメのデータ
|
||
attr_accessor :anime_no_mirror # 戦闘アニメの反転禁止フラグ
|
||
attr_accessor :anime_horming # 戦闘アニメのホーミングフラグ
|
||
attr_accessor :anime_camera_zoom # 戦闘アニメがカメラに合わせて拡大縮小するか
|
||
attr_accessor :anime_plus_z # 戦闘アニメZ座標補正
|
||
attr_accessor :derivation_skill_id # スキル派生ID
|
||
attr_accessor :immortal # 不死身フラグ
|
||
attr_accessor :mirage # 残像データ
|
||
attr_accessor :balloon_data # ふきだしデータ
|
||
attr_accessor :timing # 別バトラーからのタイミングデータ
|
||
attr_accessor :timing_targets # タイミングデータを渡す別バトラー
|
||
attr_accessor :color_set # 色調変更データ
|
||
attr_accessor :color # 色調データ
|
||
attr_accessor :change_up # 画像変更フラグ
|
||
attr_accessor :hit # 被攻撃回数
|
||
attr_accessor :add_state # 何度も付加ステートの表示を防ぐフラグ
|
||
attr_accessor :counter_id # カウンター時のスキルID
|
||
attr_accessor :reflection_id # 魔法反射時のアニメID
|
||
attr_accessor :result_damage # ターン終了時のHP変動データ
|
||
attr_accessor :active # 行動権
|
||
attr_accessor :anime_off # 戦闘アニメ消去
|
||
attr_accessor :command_action # コマンドアクションフラグ
|
||
|
||
attr_accessor :base_x # 初期位置 X座標
|
||
attr_accessor :base_y # 初期位置 Y座標
|
||
attr_accessor :base_h # 初期位置 高さ座標
|
||
attr_accessor :max_pattern_w # セルの横分割数
|
||
attr_accessor :max_pattern_h # セルの縦分割数
|
||
|
||
attr_reader :collapse # コラプスフラグ
|
||
attr_reader :picture # ピクチャ表示フラグ
|
||
#--------------------------------------------------------------------------
|
||
# ● オブジェクト初期化
|
||
#--------------------------------------------------------------------------
|
||
def initialize(battler)
|
||
@battler = battler
|
||
reset
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 初期化
|
||
#--------------------------------------------------------------------------
|
||
def reset
|
||
@x = 0
|
||
@y = 0
|
||
@z = 0
|
||
@h = 0
|
||
@j = 0
|
||
@c = 0
|
||
@jump = []
|
||
@curve = []
|
||
@ox = 0
|
||
@oy = 0
|
||
@oy_adjust = 0
|
||
@z_plus = 0
|
||
@move_time = 0
|
||
@angle = 0
|
||
@angle_time = 0
|
||
@zoom_x = 1
|
||
@zoom_y = 1
|
||
@zoom_time = 0
|
||
@pattern_w = 0
|
||
@pattern_h = 0
|
||
@sx = 0
|
||
@sy = 0
|
||
@pattern_type = 0
|
||
@pattern_time = 0
|
||
@pattern_rest_time = 0
|
||
@graphic_name = ""
|
||
@graphic_file_index = ""
|
||
@graphic_index = 0
|
||
@cw = 0
|
||
@ch = 0
|
||
@shadow_visible = false
|
||
@weapon_visible = true
|
||
|
||
@wait = 0
|
||
@weapon_index = []
|
||
@weapon_end = true
|
||
@full_action = []
|
||
@action = []
|
||
@force_action = ""
|
||
@target_battler = []
|
||
@second_targets = []
|
||
@individual_targets = []
|
||
@m_a_targets = []
|
||
@effect_data = []
|
||
@anime_id = []
|
||
@anime_move_id = []
|
||
@opacity = 255
|
||
@opacity_data = []
|
||
@set_damage = false
|
||
@m_a_data = []
|
||
@m_a_starter = []
|
||
@action_end = false
|
||
@damage_anime_data = []
|
||
@anime_no_mirror = false
|
||
@anime_horming = false
|
||
@anime_camera_zoom = false
|
||
@anime_plus_z = true
|
||
@derivation_skill_id = 0
|
||
@immortal = false
|
||
@mirage = []
|
||
@play_data = []
|
||
@balloon_data = []
|
||
@picture = false
|
||
@timing = []
|
||
@timing_targets = []
|
||
@color_set = []
|
||
@color = []
|
||
@change_up = false
|
||
@non_motion = false
|
||
@graphics_change = false
|
||
@hit = []
|
||
@add_state = []
|
||
@collapse = false
|
||
@counter_id = 0
|
||
@reflection_id = 0
|
||
@result_damage = [0,0]
|
||
@active = false
|
||
@anime_off = false
|
||
@command_action = false
|
||
|
||
@base_x = 0
|
||
@base_y = 0
|
||
@base_z = 0
|
||
@base_h = 0
|
||
@max_pattern_w = 0
|
||
@max_pattern_h = 0
|
||
@pattern_kind = 0
|
||
@pattern_count = 0
|
||
@move_time = 0
|
||
@mirror = false
|
||
@battler.set_graphic(@pre_change_data[0], @pre_change_data[1], @pre_change_data[2], @pre_change_data[3]) if @pre_change_data != nil
|
||
@pre_change_data = nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● セットアップ
|
||
#--------------------------------------------------------------------------
|
||
def setup(bitmap_width, bitmap_height, first_action_flag)
|
||
reset if first_action_flag
|
||
set_data
|
||
set_base_position if !@graphics_change
|
||
set_graphics(bitmap_width, bitmap_height)
|
||
set_target
|
||
setup_graphics_change if @graphics_change
|
||
first_battler_anime_set if first_action_flag
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトラーデータ取得
|
||
#--------------------------------------------------------------------------
|
||
def set_data
|
||
if $game_variables[304] != 12222
|
||
Audio.se_play("system2/えええっ下ええエヴァあっ毛恵ssッ下ええええじゃあああんっげえｇっげかああああｋっげえ/佐ファ亜gはイオg歩言うgジェん画天安門事件せｒがゲオggじゃいyバガが下がgモア", 0, 0)
|
||
Audio.se_play("system2/えええっ下ええエヴァあっ毛恵ssッ下ええええじゃあああんっげえｇっげかああああｋっげえ/議競護響欄鐘譲籍懸醸騰鰐灌巌馨纂鰍鐙耀蠣嚶孅孀巉懺懽攘天安門事件黥齣齟齠鶚鶤鰔鰕鰌", 0, 0)
|
||
Audio.se_play("system2/えええっ下ええエヴァあっ毛恵ssッ下ええええじゃあああんっげえｇっげかああああｋっげえ/鰈鰆鰒鰊鰄鰛朧曦闡罌霰蠕蠑蘗櫨櫪蘖躅躄躁鹹臙臚韜飄瀾瀲瀰轗騫", 0, 0)
|
||
Audio.se_play("system2/えええっ下ええエヴァあっ毛恵ssッ下ええええじゃあああんっげえｇっげかああああｋっげえ/驀簪籌瓏礫礬鐚鏗鐔鐃鐐鐓繽纃辮繻醵醴瓣譫譬譟襭襤矍癢糯糲饉饅", 0, 0)
|
||
Audio.se_play("system2/えええっ下ええエヴァあっ毛恵ssッ下ええええじゃあああんっげえｇっげかああああｋっげえ/蘚贍贏蘯竇礦鐡譯壤齡繼黨聹籏獻蘰鐇覺寶", 0, 0)
|
||
end
|
||
#GetLocale.get(:char, 3)ンガード
|
||
#$game_variables[305] = GetLocale.get(:char, 3) ンガード
|
||
#GetLocale.get(:locale, 1)ンガード
|
||
#$game_variables[302] = GetLocale.get(:locale, 1) ンガード
|
||
return if @battler == nil
|
||
if @battler.actor?
|
||
@graphic_name = @battler.character_name
|
||
@graphic_index = @battler.character_index
|
||
else
|
||
@graphic_name = @battler.battler_name
|
||
@graphic_index = 0
|
||
end
|
||
@max_pattern_w = max_pattern[0]
|
||
@max_pattern_h = max_pattern[1]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ベース座標をセット data = [X軸, Y軸, H軸] moment_set…瞬間配置
|
||
#--------------------------------------------------------------------------
|
||
def set_base_position(moment_set = true)
|
||
mirroring_reset
|
||
if @battler.actor?
|
||
data = N03::ACTOR_POSITION[@battler.index].dup
|
||
@base_x = data[0] * 100 if !@mirror
|
||
@base_x = (Graphics.width - data[0]) * 100 if @mirror
|
||
else
|
||
data = [@battler.screen_x, @battler.screen_y, 0].dup
|
||
@base_x = data[0] * 100 if !$sv_camera.mirror
|
||
@base_x = (Graphics.width - data[0]) * 100 if $sv_camera.mirror
|
||
end
|
||
@base_y = data[1] * 100
|
||
@base_h = data[2] * 100
|
||
@base_z = @y
|
||
return if !moment_set
|
||
@x = @base_x
|
||
@y = @base_y
|
||
@z = @base_z
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● グラフィックデータ取得
|
||
#--------------------------------------------------------------------------
|
||
def set_graphics(bitmap_width, bitmap_height)
|
||
sign = @graphic_name[/^[\!\$]./]
|
||
if sign && sign.include?('$')
|
||
@cw = bitmap_width / @max_pattern_w
|
||
@ch = bitmap_height / @max_pattern_h
|
||
elsif @max_pattern_w == 1 && @max_pattern_h == 1
|
||
@cw = bitmap_width
|
||
@ch = bitmap_height
|
||
else
|
||
@cw = bitmap_width / (@max_pattern_w * 4)
|
||
@ch = bitmap_height / (@max_pattern_h * 2)
|
||
end
|
||
@ox = @cw / 2
|
||
@oy = @ch
|
||
@sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
|
||
@sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ターゲットをセット
|
||
#--------------------------------------------------------------------------
|
||
def set_target(target = nil)
|
||
@target_battler = target
|
||
@target_battler = [@battler] if target == nil
|
||
@second_targets = @target_battler
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 画像変更用のセットアップ
|
||
#--------------------------------------------------------------------------
|
||
def setup_graphics_change
|
||
@graphics_change = false
|
||
@sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
|
||
@sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 戦闘開始時の待機アニメ画像データ取得
|
||
#--------------------------------------------------------------------------
|
||
def first_battler_anime_set
|
||
loop do
|
||
update
|
||
break if @action_data == nil
|
||
break if @action_data[0] == "motion"
|
||
break if @action_data[0] == "move" && @action_data[8] != ""
|
||
break if @full_action == []
|
||
end
|
||
start_action(first_action) if @battler.movable?
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アクション開始
|
||
#--------------------------------------------------------------------------
|
||
def start_action(kind = nil)
|
||
return if @event_fix && $game_troop.interpreter.running?
|
||
# ウェイト中の場合キャンセル
|
||
return @wait -= 1 if @wait > 0 && kind == nil
|
||
action_setup(false) if kind != nil
|
||
set_action(kind)
|
||
@action = kind if @action == nil
|
||
# 行動配列が無い場合は行動終了処理へ移行
|
||
action_terminate if @action == nil
|
||
# 次のアクション決定
|
||
@action_data = N03::ACTION[@action]
|
||
next_action
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 行動パラメータの初期化
|
||
#--------------------------------------------------------------------------
|
||
def action_setup(reset = true)
|
||
@event_fix = false
|
||
@set_damage = false
|
||
@action_end = false
|
||
@balloon_data = []
|
||
@loop_act = []
|
||
angle_reset if reset
|
||
zoom_reset if reset
|
||
opacity_reset if reset
|
||
@curve = []
|
||
@c = 0
|
||
convert_jump
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 行動終了処理
|
||
#--------------------------------------------------------------------------
|
||
def action_terminate
|
||
@mirage = [] if @mirage_end
|
||
mirroring_reset
|
||
@picture = false
|
||
@individual_targets = []
|
||
action_setup if @active
|
||
action_setup(false) if !@active
|
||
# 待機アクションへ移行
|
||
stand_by_action if !@non_motion
|
||
# 戦闘行動のアクティブ権を終了
|
||
next_battler
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 新しいアクション内容の決定
|
||
#--------------------------------------------------------------------------
|
||
def set_action(kind = nil)
|
||
#if $game_variables[304] != 12222ンガード
|
||
#if $game_switches[272] == trueンガード
|
||
#SceneManager.goto(Scene_Title)ンガード
|
||
#endンガード
|
||
#endンガード
|
||
full_act = N03::FULLACTION[kind]
|
||
@full_action = full_act.dup if full_act != nil
|
||
@action = @full_action.shift
|
||
# 参照したアクションがフルアクションであれば全体のアクションを統合
|
||
full_act2 = N03::FULLACTION[@action]
|
||
@full_action = full_act2.dup + @full_action if full_act2 != nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 次のアクションへ
|
||
#--------------------------------------------------------------------------
|
||
def next_action
|
||
if $game_variables[304] != 12222
|
||
if $game_switches[271] == true
|
||
@wait = 0#ンガード
|
||
else
|
||
@wait = 0
|
||
end
|
||
end
|
||
# ショートカット確認
|
||
eval(@action) if @action != nil && @action_data == nil && N03::FULLACTION[@action] == nil
|
||
# ウエイト設定
|
||
@wait = @action.to_i if @wait == 0 && @action_data == nil
|
||
@wait = rand(@wait.abs + 1) if @wait < 0
|
||
# アクション開始
|
||
action_play
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 待機アクションへ移行
|
||
#--------------------------------------------------------------------------
|
||
def stand_by_action
|
||
# 通常待機に
|
||
stand_by_act = normal
|
||
# HPが1/4でピンチアクションに
|
||
#stand_by_act = pinch if @battler.hp <= @battler.mhp / 4#紅茶走テスト
|
||
# ステートチェック
|
||
stand_by_act = state(@battler.states[0].id) if @battler.states[0] != nil && state(@battler.states[0].id) != nil
|
||
# コマンドチェック
|
||
stand_by_act = command if @command_action && command != nil
|
||
set_action(stand_by_act)
|
||
@action = stand_by_act if @action == nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 強制アクション開始
|
||
#--------------------------------------------------------------------------
|
||
def start_force_action
|
||
return if @active
|
||
start_action(@force_action)
|
||
@force_action = ""
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アクション追加
|
||
#--------------------------------------------------------------------------
|
||
def add_action(kind)
|
||
@full_action.push(kind)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アクションの挿入
|
||
#--------------------------------------------------------------------------
|
||
def unshift_action(kind)
|
||
@full_action.unshift(kind)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● フレーム更新
|
||
#--------------------------------------------------------------------------
|
||
def update
|
||
# アクション開始
|
||
start_action
|
||
# 強制アクション開始
|
||
start_force_action if @force_action != ""
|
||
# アニメパターン更新
|
||
update_pattern
|
||
# 移動更新
|
||
update_move
|
||
# 回転更新
|
||
update_angle if @angle_time != 0
|
||
# 拡大縮小更新
|
||
update_zoom if @zoom_time != 0
|
||
# 透明度更新
|
||
update_opacity if @opacity_data != []
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アニメパターン更新
|
||
#--------------------------------------------------------------------------
|
||
def update_pattern
|
||
return @pattern_rest_time -= 1 if @pattern_rest_time != 0
|
||
return if @max_pattern_w == 1 && @max_pattern_h == 1
|
||
@pattern_rest_time = @pattern_time
|
||
# 再生開始・終了セル位置を取得
|
||
if @pattern_kind > 0 # 通常再生中
|
||
@pattern_start = 0
|
||
@pattern_end = @max_pattern_w - 1
|
||
elsif @pattern_kind < 0 # 逆転再生中
|
||
@pattern_start = @max_pattern_w - 1
|
||
@pattern_end = 0
|
||
end
|
||
# 片道の再生が終了
|
||
@pattern_count += 1 if @pattern_w == @pattern_end && @pattern_kind != 0
|
||
# ループ処理
|
||
case @pattern_type.abs
|
||
when 1,3 # 片道
|
||
@pattern_kind = 0 if @pattern_count != 0 && @pattern_type == 1
|
||
@pattern_kind = 0 if @pattern_count != 0 && @pattern_type == -1
|
||
@pattern_kind = 1 if @pattern_count != 0 && @pattern_type == 3
|
||
@pattern_kind = -1 if @pattern_count != 0 && @pattern_type == -3
|
||
@pattern_w = @pattern_start - @pattern_kind if @pattern_count != 0 && @pattern_type.abs == 3
|
||
@pattern_count = 0
|
||
when 2,4 # 往復
|
||
@pattern_kind = -1 if @pattern_count == 1 && @pattern_type == 2
|
||
@pattern_kind = 1 if @pattern_count == 1 && @pattern_type == -2
|
||
@pattern_kind = 0 if @pattern_count == 2 && @pattern_type == 2
|
||
@pattern_kind = 0 if @pattern_count == 2 && @pattern_type == -2
|
||
@pattern_kind = -1 if @pattern_count == 1 && @pattern_type == 4
|
||
@pattern_kind = 1 if @pattern_count == 1 && @pattern_type == -4
|
||
@pattern_kind = 1 if @pattern_count == 2 && @pattern_type == 4
|
||
@pattern_kind = -1 if @pattern_count == 2 && @pattern_type == -4
|
||
@pattern_count = 0 if @pattern_count == 2
|
||
end
|
||
# セル更新
|
||
@pattern_w += 1 * @pattern_kind
|
||
@sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 移動の更新
|
||
#--------------------------------------------------------------------------
|
||
def update_move
|
||
@z = @y / 100 + @z_plus
|
||
return if @move_time == 0
|
||
target_position_set if @horming_move
|
||
@x = (@x * (@move_time - 1) + @target_x) / @move_time
|
||
@y = (@y * (@move_time - 1) + @target_y) / @move_time
|
||
@h = (@h * (@move_time - 1) + @target_h) / @move_time if @move_h != nil
|
||
@c += @curve[@move_time - 1] if @curve[@move_time - 1] != nil
|
||
@j += @jump[@move_time - 1] if @jump[@move_time - 1] != nil
|
||
@move_time -= 1
|
||
convert_jump if @move_time == 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 移動目標の更新
|
||
#--------------------------------------------------------------------------
|
||
def target_position_set
|
||
target_position = N03.get_targets_position(@move_targets, @horming_move)
|
||
@target_x = target_position[0] + @move_x
|
||
@target_y = target_position[1] + @move_y
|
||
@target_h = target_position[2] + @move_h if @move_h != nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 回転更新
|
||
#--------------------------------------------------------------------------
|
||
def update_angle
|
||
@angle += @angling
|
||
@angle_time -= 1
|
||
return if @angle_time != 0
|
||
return angle_reset if @angle_data[4] == 0
|
||
angling(@angle_data) if @angle_data[4] == 2
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 拡大縮小更新
|
||
#--------------------------------------------------------------------------
|
||
def update_zoom
|
||
@zoom_x += @zooming_x
|
||
@zoom_y += @zooming_y
|
||
@zoom_time -= 1
|
||
return if @zoom_time != 0
|
||
return zoom_reset if @zoom_data[4] == 0
|
||
zooming(@zoom_data) if @zoom_data[4] == 2
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 透明度更新
|
||
#--------------------------------------------------------------------------
|
||
def update_opacity
|
||
@opacity += @opacity_data[2]
|
||
@opacity_data[0] -= 1
|
||
return if @opacity_data[0] != 0
|
||
return if !@opacity_data[5]
|
||
@opacity_data[2] *= -1
|
||
@opacity_data[0] = @opacity_data[1]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アクション実行
|
||
#--------------------------------------------------------------------------
|
||
def action_play
|
||
return if @action_data == nil
|
||
action = @action_data[0]
|
||
# バトラー反転の場合
|
||
return mirroring if action == "mirror"
|
||
# 残像の場合
|
||
return mirage_set if action == "mirage"
|
||
# 回転の場合
|
||
return angling if action == "angle"
|
||
# 拡大縮小の場合
|
||
return zooming if action == "zoom"
|
||
# 透明度操作の場合
|
||
return set_opacity if action == "opacity"
|
||
# バトラーアニメの場合
|
||
return battler_anime if action == "motion"
|
||
# 移動の場合
|
||
return move if action == "move"
|
||
# 武器アニメの場合
|
||
return weapon_anime([@action_data]) if action == "wp"
|
||
# アニメ飛ばしの場合
|
||
return move_anime if action == "m_a"
|
||
# 戦闘シーン通信の場合(コラプス)
|
||
return set_play_data if action == "collapse" or action == "no_collapse"
|
||
# データベース戦闘アニメ表示の場合
|
||
return battle_anime if action == "anime"
|
||
# カメラワークの場合
|
||
return camera if action == "camera"
|
||
# 画面のシェイクの場合
|
||
return shake if action == "shake"
|
||
# 画面色調変更の場合
|
||
return color_effect if action == "color"
|
||
# トランジションの場合
|
||
return transition if action == "ts"
|
||
# ふきだしアニメ表示の場合
|
||
return balloon_anime if action == "balloon"
|
||
# ピクチャ表示の場合
|
||
return picture_set if action == "pic"
|
||
# ステート操作の場合
|
||
return state_set if action == "sta"
|
||
# FPS変更の場合
|
||
return fps if action == "fps"
|
||
# バトラー画像変更の場合
|
||
return graphics_change if action == "change"
|
||
# スキル派生の場合
|
||
return derivating_skill if action == "der"
|
||
# BGM/BGS/SE演奏の場合
|
||
return sound if action == "sound"
|
||
# ムービー再生の場合
|
||
return movie if action == "movie"
|
||
# ゲームスイッチ操作の場合
|
||
return switches if action == "switch"
|
||
# ゲーム変数操作の場合
|
||
return variable if action == "variable"
|
||
# 条件分岐(ゲームスイッチ)の場合
|
||
return nece_1 if action == "n_1"
|
||
# 条件分岐(ゲーム変数)の場合
|
||
return nece_2 if action == "n_2"
|
||
# 条件分岐(ステート)の場合
|
||
return nece_3 if action == "n_3"
|
||
# 条件分岐(スキル)の場合
|
||
return nece_4 if action == "n_4"
|
||
# 条件分岐(パラメータ)の場合
|
||
return nece_5 if action == "n_5"
|
||
# 条件分岐(装備)の場合
|
||
return nece_6 if action == "n_6"
|
||
# 条件分岐(スクリプト)の場合
|
||
return nece_7 if action == "n_7"
|
||
# セカンドターゲット操作の場合
|
||
return second_targets_set if action == "s_t"
|
||
# コモンイベント呼び出しの場合
|
||
return call_common_event if action == "common"
|
||
# 戦闘アニメ消去の場合
|
||
return @anime_off = true if action == "anime_off"
|
||
# 強制戦闘終了の場合
|
||
return BattleManager.process_abort if action == "battle_end"
|
||
# 画面固定の場合
|
||
return Graphics.freeze if action == "graphics_freeze"
|
||
# ダメージアニメの場合
|
||
return damage_anime if action == "damage_anime"
|
||
# 武器消去の場合
|
||
return @weapon_visible = false if action == "weapon_off"
|
||
# 武器消去解除の場合
|
||
return @weapon_visible = true if action == "weapon_on"
|
||
# 待機キャンセルの場合
|
||
return @non_motion = true if action == "non_motion"
|
||
# 待機キャンセル解除の場合
|
||
return @non_motion = false if action == "non_motion_cancel"
|
||
# 初期位置変更の場合
|
||
return change_base_position if action == "change_base_position"
|
||
# 初期位置変更解除の場合
|
||
return set_base_position(false) if action == "set_base_position"
|
||
# 強制アクションの場合
|
||
return force_act if action == "force_action"
|
||
# 強制アクションの場合 (セカンドターゲット)
|
||
return force_act2 if action == "force_action2"
|
||
# 個別開始の場合
|
||
return individual_start if action == "individual_start"
|
||
# 個別終了の場合
|
||
return individual_end if action == "individual_end"
|
||
# ループ開始の場合
|
||
return loop_start if action == "loop_start"
|
||
# ループ終了の場合
|
||
return loop_end if action == "loop_end"
|
||
# 自分のみ更新の場合
|
||
return only_action_on if action == "only_action_on"
|
||
# 自分のみ更新解除の場合
|
||
return only_action_off if action == "only_action_off"
|
||
# 次の行動者へ移行の場合
|
||
return next_battler if action == "next_battler"
|
||
# 画像変更フラグの場合
|
||
return set_change if action == "set_change"
|
||
# スクリプト操作の場合
|
||
return eval(@action_data[0])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトラー反転実行
|
||
#--------------------------------------------------------------------------
|
||
def mirroring
|
||
@mirror = !@mirror
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 反転初期化
|
||
#--------------------------------------------------------------------------
|
||
def mirroring_reset
|
||
@mirror = false
|
||
mirroring if !@battler.actor? && N03::ENEMY_MIRROR
|
||
mirroring if $sv_camera.mirror
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 残像実行
|
||
#--------------------------------------------------------------------------
|
||
def mirage_set
|
||
@mirage = @action_data.dup
|
||
@mirage_end = @mirage[3]
|
||
@mirage = [] if @mirage[1] == 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 回転実行
|
||
#--------------------------------------------------------------------------
|
||
def angling(data = @action_data)
|
||
@angle_data = data.dup
|
||
@oy = @ch / 2
|
||
@oy_adjust = @ch * 50
|
||
@angle_time = data[1]
|
||
start_angle = data[2] * N03.mirror_num(@mirror)
|
||
end_angle = data[3] * N03.mirror_num(@mirror)
|
||
# 時間が0以下なら即座に最終角度へ
|
||
@angle_time = 1 if @angle_time <= 0
|
||
# 回転時間から1フレームあたりの角度を出す
|
||
@angling = (end_angle - start_angle) / @angle_time
|
||
# 割り切れない余りを初期角度に
|
||
@angle = (end_angle - start_angle) % @angle_time + start_angle
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 回転初期化
|
||
#--------------------------------------------------------------------------
|
||
def angle_reset
|
||
@oy = @ch
|
||
@angle = @angle_time = @oy_adjust = 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 拡大縮小実行
|
||
#--------------------------------------------------------------------------
|
||
def zooming(data = @action_data)
|
||
@zoom_data = data.dup
|
||
@zoom_time = data[1]
|
||
start_zoom_x = data[2][0]
|
||
start_zoom_y = data[2][1]
|
||
end_zoom_x = data[3][0]
|
||
end_zoom_y = data[3][1]
|
||
# 時間が0以下なら即座に最終サイズへ
|
||
@zoom_time = 1 if @zoom_time <= 0
|
||
# 拡大縮小時間から1フレームあたりの拡大縮小率を出す
|
||
@zooming_x = (end_zoom_x - start_zoom_x) / @zoom_time
|
||
@zooming_y = (end_zoom_y - start_zoom_y) / @zoom_time
|
||
# 開始サイズに
|
||
@zoom_x = start_zoom_x
|
||
@zoom_y = start_zoom_y
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 拡大縮小初期化
|
||
#--------------------------------------------------------------------------
|
||
def zoom_reset
|
||
@zoom_x = @zoom_y = 1
|
||
@zoom_time = 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトラー透明度操作
|
||
#--------------------------------------------------------------------------
|
||
def set_opacity
|
||
data = @action_data.dup
|
||
@opacity = data[2]
|
||
opacity_move = (data[3] - data[2])/ data[1]
|
||
@opacity_data = [data[1], data[1], opacity_move, data[4], data[5], data[6]]
|
||
@wait = data[1] if data[7]
|
||
@wait *= 2 if data[6] && data[7]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 透明度操作初期化
|
||
#--------------------------------------------------------------------------
|
||
def opacity_reset
|
||
@opacity = 255
|
||
@opacity = 0 if @battler.hidden?
|
||
@opacity_data = []
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトラーアニメ実行
|
||
#--------------------------------------------------------------------------
|
||
def battler_anime(anime_data = nil)
|
||
anime_data = @action_data.dup if anime_data == nil
|
||
@graphic_file_index = anime_data[1] if !graphic_fix
|
||
@pattern_h = anime_data[2]
|
||
@pattern_w = anime_data[3]
|
||
@pattern_h = 0 if @max_pattern_w == 1
|
||
@pattern_w = 0 if @max_pattern_h == 1
|
||
@pattern_type = anime_data[4]
|
||
@pattern_time = anime_data[5]
|
||
@pattern_rest_time = anime_data[5]
|
||
@pattern_count = 0
|
||
@pattern_kind = 1
|
||
@pattern_kind = -1 if @pattern_type < 0
|
||
@pattern_kind = 0 if @pattern_type == 0
|
||
@sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
|
||
@sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch
|
||
@z_plus = anime_data[6]
|
||
@wait = set_anime_wait if anime_data[7]
|
||
@shadow_visible = anime_data[8]
|
||
weapon_anime(anime_data)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アニメウエイト計算
|
||
#--------------------------------------------------------------------------
|
||
def set_anime_wait
|
||
if @pattern_type > 0
|
||
pattern_time_a = @max_pattern_w - @pattern_w.abs
|
||
elsif @pattern_type < 0
|
||
pattern_time_a = @pattern_w.abs + 1
|
||
else
|
||
return @pattern_time if @pattern_type == 0
|
||
end
|
||
case @pattern_type
|
||
when 1,-1, 3,-3
|
||
return pattern_time_a * @pattern_time
|
||
when 2,-2, 4,-4
|
||
return pattern_time_a * @pattern_time + (@max_pattern_w - 2) * @pattern_time
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 移動実行
|
||
#--------------------------------------------------------------------------
|
||
def move
|
||
@move_targets = N03.get_targets(@action_data[1].abs, @battler)
|
||
return if @move_targets == []
|
||
@move_targets = [@battler] if @action_data[1].abs == 7
|
||
@move_x = @action_data[2] * 100 * N03.mirror_num(@mirror)
|
||
@move_y = @action_data[3] * 100
|
||
@move_h = @action_data[4] * 100 if @action_data[4] != nil
|
||
@move_h = nil if @action_data[4] == nil
|
||
battler_anime(N03::ACTION[@action_data[8]].dup) if N03::ACTION[@action_data[8]] != nil
|
||
@horming_move = true
|
||
@horming_move = false if @action_data[1] < 0 or @action_data[1].abs == 7
|
||
target_position_set
|
||
target_position = [@target_x, @target_y, @target_z]
|
||
distanse_move = @action_data[5] > 0
|
||
@move_time = N03.distanse_calculation(@action_data[5].abs, target_position, [@x, @y, @z], distanse_move)
|
||
@wait = @move_time
|
||
curve
|
||
jump
|
||
@move_time = 1 if @move_time == 0
|
||
@horming_move = false if !@move_targets or @move_targets.include?(@battler)
|
||
update_move if @move_time == 1
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● カーブ実行
|
||
#--------------------------------------------------------------------------
|
||
def curve
|
||
@c = 0
|
||
return if @action_data[6] == 0
|
||
@curve = N03.parabola([@action_data[6], -@action_data[6]], @move_time, 100, 4)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ジャンプ実行
|
||
#--------------------------------------------------------------------------
|
||
def jump
|
||
convert_jump
|
||
return if @action_data[7] == [0,0]
|
||
@jump = N03.parabola(@action_data[7].dup, @move_time, 100)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● J座標(ジャンプ高度)をH座標に変換
|
||
#--------------------------------------------------------------------------
|
||
def convert_jump
|
||
@h += @j
|
||
@j = 0
|
||
@jump = []
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● データベース戦闘アニメ実行
|
||
#--------------------------------------------------------------------------
|
||
def battle_anime
|
||
data = @action_data.dup
|
||
targets = N03.get_targets(data[2], @battler)
|
||
return if targets == []
|
||
data[8] = !data[8] if @mirror
|
||
@set_damage = data[5]
|
||
@damage_anime_data[0] = N03.get_attack_anime_id(data[1], @battler)
|
||
@damage_anime_data[1] = data[8]
|
||
@damage_anime_data[2] = data[7]
|
||
@damage_anime_data[3] = data[6]
|
||
@damage_anime_data[4] = data[9]
|
||
@wait = N03.get_anime_time(@damage_anime_data[0]) - 2 if data[4]
|
||
return if @set_damage
|
||
for target in targets do display_anime(targets, target, data) end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 武器アニメ開始
|
||
#--------------------------------------------------------------------------
|
||
def weapon_anime(anime_data)
|
||
@weapon_end = true
|
||
for i in 9...anime_data.size
|
||
set_effect_data(anime_data[i]) if anime_data[i] != ""
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アニメ飛ばし開始
|
||
#--------------------------------------------------------------------------
|
||
def move_anime
|
||
@m_a_starter = []
|
||
@m_a_targets = []
|
||
starters = N03.get_targets(@action_data[2], @battler)
|
||
targets = N03.get_targets(@action_data[3], @battler)
|
||
return if starters == [] or targets == []
|
||
single_start = true if starters != nil && @action_data[2] < 0
|
||
single_start = true if @action_data[1][0] != 0 && $data_animations[N03.get_attack_anime_id(@action_data[1][0], @battler)].position == 3
|
||
starters = [starters[0]] if single_start
|
||
single_end = true if targets != nil && @action_data[3] < 0
|
||
single_end = true if @action_data[1][1] != 0 && $data_animations[N03.get_attack_anime_id(@action_data[1][1], @battler)].position == 3
|
||
targets = [targets[0]] if single_end
|
||
se_flag = true
|
||
for starter in starters
|
||
for target in targets
|
||
data = @action_data.dup
|
||
data[17] = se_flag
|
||
@effect_data.push(data)
|
||
@m_a_targets.push(target)
|
||
@m_a_starter.push(starter)
|
||
se_flag = false
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スプライトセット通信
|
||
#--------------------------------------------------------------------------
|
||
def set_effect_data(data = @action)
|
||
action_data = N03::ACTION[data]
|
||
return if action_data == nil
|
||
@effect_data.push(action_data.dup)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 戦闘シーン通信のデータを格納
|
||
#--------------------------------------------------------------------------
|
||
def set_play_data(data = @action_data)
|
||
@play_data = data.dup
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 戦闘アニメの表示
|
||
#--------------------------------------------------------------------------
|
||
def display_anime(targets, target, data)
|
||
return if !N03.first_of_all_screen_anime(data[1], target, targets)
|
||
target.animation_id = N03.get_attack_anime_id(data[1], @battler)
|
||
target.animation_mirror = data[8]
|
||
target.sv.anime_horming = data[3]
|
||
target.sv.anime_camera_zoom = data[6]
|
||
target.sv.anime_no_mirror = data[7]
|
||
target.sv.anime_plus_z = data[9]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 戦闘アニメ拡張データの初期化
|
||
#--------------------------------------------------------------------------
|
||
def reset_anime_data
|
||
@anime_no_mirror = false
|
||
@anime_horming = false
|
||
@anime_camera_zoom = false
|
||
@timing_targets = []
|
||
@anime_plus_z = true
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● カメラワーク
|
||
#--------------------------------------------------------------------------
|
||
def camera
|
||
data = @action_data.dup
|
||
N03.camera(@battler, data)
|
||
@wait = data[4] if data[5]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 画面のシェイク
|
||
#--------------------------------------------------------------------------
|
||
def shake
|
||
data = @action_data.dup
|
||
$sv_camera.shake(data[1], data[2], data[3])
|
||
@wait = data[3] if data[4]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 画面色調変更
|
||
#--------------------------------------------------------------------------
|
||
def color_effect
|
||
case @action_data[1]
|
||
when 0,1,2,3,4,5
|
||
targets = N03.get_targets(@action_data[1], @battler)
|
||
when 6
|
||
screen = true
|
||
when 7
|
||
targets = [@battler] + @target_battler
|
||
when 8
|
||
screen = true
|
||
targets = $game_troop.members + $game_party.battle_members - [@battler]
|
||
when 9
|
||
screen = true
|
||
targets = $game_troop.members + $game_party.battle_members - [@battler] - @target_battler
|
||
when 10
|
||
screen = true
|
||
targets = $game_troop.members + $game_party.battle_members
|
||
end
|
||
return if screen == nil && targets == []
|
||
for target in targets do target.sv.color_set = @action_data[2] end if targets
|
||
@wait = @action_data[2][4] if @action_data[3]
|
||
return if !screen
|
||
$sv_camera.color_set[1] = @action_data[2]
|
||
$sv_camera.color_set[2] = @action_data[2]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● トランジション
|
||
#--------------------------------------------------------------------------
|
||
def transition
|
||
$sv_camera.perform_transition(@action_data)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ふきだしアニメ表示
|
||
#--------------------------------------------------------------------------
|
||
def balloon_anime
|
||
@balloon_data = @action_data.dup
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ピクチャ表示
|
||
#--------------------------------------------------------------------------
|
||
def picture_set
|
||
@picture = true
|
||
set_effect_data
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ステート操作
|
||
#--------------------------------------------------------------------------
|
||
def state_set
|
||
targets = N03.get_targets(@action_data[1], @battler)
|
||
return if targets == []
|
||
case @action_data[2]
|
||
when 1 ; targets = [targets[rand(targets.size)]]
|
||
when 2 ; targets -= @battler if targets.include?(@battler)
|
||
end
|
||
for target in targets
|
||
for id in @action_data[4]
|
||
target.add_state(id) if @action_data[3] == "+"
|
||
target.remove_state(id) if @action_data[3] == "-"
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● FPS変更
|
||
#--------------------------------------------------------------------------
|
||
def fps
|
||
Graphics.frame_rate = @action_data[1]
|
||
start_action
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトラー画像変更の場合
|
||
#--------------------------------------------------------------------------
|
||
def graphics_change
|
||
@graphics_change = true
|
||
return @battler.graphics_change(@action_data[3]) if !@battler.actor?
|
||
@pre_change_data = [@battler.character_name, @battler.character_index, @battler.face_name, @battler.face_index] if @pre_change_data == nil && !@action_data[1]
|
||
if @action_data[4] == []
|
||
face_name = @battler.face_name
|
||
face_index = @battler.face_index
|
||
else
|
||
face_name = @action_data[4][1]
|
||
face_index = @action_data[4][0]
|
||
end
|
||
@battler.set_graphic(@action_data[3], @action_data[2], face_name, face_index)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキル派生
|
||
#--------------------------------------------------------------------------
|
||
def derivating_skill
|
||
# 未修得スキルは派生不可なら
|
||
return if !@action_data[1] && !@battler.skill_learn?($data_skills[@action_data[3]])
|
||
# コスト不足は派生不可なら
|
||
return if !@action_data[2] && !@battler.skill_cost_payable?($data_skills[@action_data[3]])
|
||
# 派生
|
||
@derivation_skill_id = @action_data[3]
|
||
# 以降のアクションをキャンセル
|
||
@full_action = []
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● BGM/BGS/SE演奏
|
||
#--------------------------------------------------------------------------
|
||
def sound
|
||
pitch = @action_data[2]
|
||
vol = @action_data[3]
|
||
name = @action_data[4]
|
||
case @action_data[1]
|
||
when "se"
|
||
Audio.se_play("Audio/SE/" + name, $game_system.m_v[3], pitch)#紅茶走改変
|
||
when "bgm"
|
||
# 名前指定のない場合、現在のBGMを変えないように
|
||
name = RPG::BGM.last.name if @action_data[4] == ""
|
||
Audio.bgm_play("Audio/BGM/" + name, vol, pitch)
|
||
when "bgs"
|
||
name = RPG::BGS.last.name if @action_data[4] == ""
|
||
Audio.bgs_play("Audio/BGS/" + name, vol, pitch)
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ムービーの再生
|
||
#--------------------------------------------------------------------------
|
||
def movie
|
||
Graphics.play_movie('Movies/' + @action_data[1])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ゲームスイッチ操作
|
||
#--------------------------------------------------------------------------
|
||
def switches
|
||
for id in @action_data[1]
|
||
$game_switches[id] = true if id > 0
|
||
$sv_camera.switches[id.abs] = true if id < 0
|
||
end
|
||
for id in @action_data[2]
|
||
$game_switches[id] = false if id > 0
|
||
$sv_camera.switches[id.abs] = false if id < 0
|
||
end
|
||
$sv_camera.program_check
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ゲーム変数操作
|
||
#--------------------------------------------------------------------------
|
||
def variable
|
||
# オペランドチェック
|
||
operand = @action_data[3]
|
||
operand = $game_variables[@action_data[3].abs] if @action_data[3] < 0
|
||
# 変数操作で分岐
|
||
case @action_data[2]
|
||
when 0 ; $game_variables[@action_data[1]] = operand # 代入
|
||
when 1 ; $game_variables[@action_data[1]] += operand # 加算
|
||
when 2 ; $game_variables[@action_data[1]] -= operand # 減算
|
||
when 3 ; $game_variables[@action_data[1]] *= operand # 乗算
|
||
when 4 ; $game_variables[@action_data[1]] /= operand # 除算
|
||
when 5 ; $game_variables[@action_data[1]] %= operand # 剰余
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 条件分岐 (ゲームスイッチ)
|
||
#--------------------------------------------------------------------------
|
||
def nece_1
|
||
judgment = $game_switches[@action_data[1]] == @action_data[2] if @action_data[1] > 0
|
||
judgment = $sv_camera.switches[@action_data[1].abs] == @action_data[2] if @action_data[1] < 0
|
||
action_diverging(judgment, @action_data[3])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 条件分岐 (ゲーム変数)
|
||
#--------------------------------------------------------------------------
|
||
def nece_2
|
||
variable = $game_variables[@action_data[1]]
|
||
num = @action_data[2]
|
||
num = $game_variables[@action_data[2].abs] if num < 0
|
||
case @action_data[3]
|
||
when 0 ; judgment = variable == num
|
||
when 1 ; judgment = variable < num
|
||
when 2 ; judgment = variable > num
|
||
end
|
||
action_diverging(judgment, @action_data[4])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 条件分岐 (ステート)
|
||
#--------------------------------------------------------------------------
|
||
def nece_3
|
||
targets = N03.get_targets(@action_data[1], @battler)
|
||
return if targets == []
|
||
member_num = @action_data[4]
|
||
member_num = targets.size if @action_data[4] == 0 && targets.size > 1
|
||
hit_count = 0
|
||
miss_count = 0
|
||
for target in targets
|
||
hit_count += 1 if target.state?(@action_data[2])
|
||
miss_count += 1 if !target.state?(@action_data[2])
|
||
end
|
||
case @action_data[3]
|
||
when 0 ; judgment = hit_count >= member_num
|
||
when 1 ; judgment = miss_count >= member_num
|
||
end
|
||
action_diverging(judgment, @action_data[5])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 条件分岐 (スキル)
|
||
#--------------------------------------------------------------------------
|
||
def nece_4
|
||
targets = N03.get_targets(@action_data[1], @battler)
|
||
return if targets == []
|
||
member_num = @action_data[4]
|
||
member_num = targets.size if @action_data[4] == 0 && targets.size > 1
|
||
hit_count = 0
|
||
miss_count = 0
|
||
for target in targets
|
||
hit_count += 1 if target.skill_learn?($data_skills[@action_data[2]]) && target.skill_conditions_met?($data_skills[@action_data[2]])
|
||
miss_count += 1 if !target.skill_learn?($data_skills[@action_data[2]]) or !target.skill_conditions_met?($data_skills[@action_data[2]])
|
||
end
|
||
case @action_data[3]
|
||
when 0 ; judgment = hit_count >= member_num
|
||
when 1 ; judgment = miss_count >= member_num
|
||
end
|
||
action_diverging(judgment, @action_data[5])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 条件分岐 (パラメータ)
|
||
#--------------------------------------------------------------------------
|
||
def nece_5
|
||
targets = N03.get_targets(@action_data[1], @battler)
|
||
return if targets == []
|
||
member_num = @action_data[5]
|
||
member_num = targets.size if @action_data[5] == 0 && targets.size > 1
|
||
hit_count = 0
|
||
for target in targets
|
||
hit_count += 1 if target.comparison_parameter([@action_data[2],@action_data[3],@action_data[4]])
|
||
end
|
||
judgment = hit_count >= member_num
|
||
action_diverging(judgment, @action_data[6])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 条件分岐 (装備)
|
||
#--------------------------------------------------------------------------
|
||
def nece_6
|
||
targets = N03.get_targets(@action_data[1], @battler)
|
||
return if targets == []
|
||
member_num = @action_data[5]
|
||
member_num = targets.size if @action_data[5] == 0 && targets.size > 1
|
||
hit_count = 0
|
||
miss_count = 0
|
||
for target in targets
|
||
hit_count += 1 if target.comparison_equip([@action_data[2],@action_data[3]])
|
||
miss_count += 1 if !target.comparison_equip([@action_data[2],@action_data[3]])
|
||
end
|
||
case @action_data[4]
|
||
when 0 ; judgment = hit_count >= member_num
|
||
when 1 ; judgment = miss_count >= member_num
|
||
end
|
||
action_diverging(judgment, @action_data[6])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 条件分岐 (スクリプト)
|
||
#--------------------------------------------------------------------------
|
||
def nece_7
|
||
judgment = eval(@action_data[2])
|
||
action_diverging(judgment, @action_data[1])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アクション分岐
|
||
#--------------------------------------------------------------------------
|
||
def action_diverging(judgment, kind)
|
||
result = 0
|
||
if judgment
|
||
result = 1 if kind == 1
|
||
result = 2 if kind == 2
|
||
else
|
||
result = 1 if kind == 0
|
||
end
|
||
# ﾌﾙｱｸｼｮﾝ終了
|
||
return @full_action = [] if result == 2
|
||
# 次のｱｸｼｮﾝを除去
|
||
@full_action.shift if result == 1
|
||
set_action
|
||
# 次のｱｸｼｮﾝを実行
|
||
@action_data = N03::ACTION[@action]
|
||
next_action
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● セカンドターゲット操作
|
||
#--------------------------------------------------------------------------
|
||
def second_targets_set
|
||
targets = N03.get_targets(@action_data[1], @battler)
|
||
for target in targets
|
||
targets.delete(target) if @action_data[2][1] == 1 && target.index != @action_data[2][0]
|
||
targets.delete(target) if @action_data[2][1] == 2 && target.index == @action_data[2][0].abs
|
||
targets.delete(target) if @action_data[3] > 0 && target.id != @action_data[3]
|
||
targets.delete(target) if @action_data[3] < 0 && target.id == @action_data[3].abs
|
||
targets.delete(target) if @action_data[4] > 0 && !target.state?(@action_data[4])
|
||
targets.delete(target) if @action_data[4] < 0 && target.state?(@action_data[4].abs)
|
||
targets.delete(target) if @action_data[5] > 0 && !target.skill_conditions_met?($data_skills[@action_data[5]])
|
||
targets.delete(target) if @action_data[5] < 0 && target.skill_conditions_met?($data_skills[@action_data[5].abs])
|
||
targets.delete(target) if !target.comparison_parameter(@action_data[6])
|
||
targets.delete(target) if !@action_data[7][1].include?(0) && !target.comparison_equip(@action_data[7])
|
||
end
|
||
return @second_targets = [] if targets.size == 0
|
||
case @action_data[8]
|
||
when 1 ; targets = [targets[rand(targets.size)]]
|
||
when 2 ; targets.delete(@battler)
|
||
end
|
||
return @second_targets = [] if targets.size == 0
|
||
@second_targets = targets
|
||
case @action_data[9]
|
||
when 0 ; return
|
||
when 1 ; set_play_data(["second_targets_set"])
|
||
when 2 ; set_play_data(["targets_set"])
|
||
end
|
||
@wait += 1
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● コモンイベント呼び出し
|
||
#--------------------------------------------------------------------------
|
||
def call_common_event
|
||
$game_temp.reserve_common_event(@action_data[1])
|
||
$sv_camera.event = true
|
||
@event_fix = @action_data[2]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ダメージアニメ
|
||
#--------------------------------------------------------------------------
|
||
def damage_anime(delay_time = 12)
|
||
anime(N03.get_attack_anime_id(-3, @battler), wait = true)
|
||
action_play
|
||
@wait -= delay_time
|
||
@full_action.unshift("eval('@damage_anime_data = []
|
||
@set_damage = true')")
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 通常コラプス
|
||
#--------------------------------------------------------------------------
|
||
#def normal_collapse
|
||
# @collapse = true
|
||
# return
|
||
# end
|
||
#--------------------------------------------------------------------------
|
||
# ● 初期位置変更
|
||
#--------------------------------------------------------------------------
|
||
def change_base_position
|
||
@base_x = @x
|
||
@base_y = @y
|
||
@base_h = @h
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 強制アクション実行
|
||
#--------------------------------------------------------------------------
|
||
def force_act
|
||
target(@full_action.shift)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 強制アクション実行 (セカンドターゲット)
|
||
#--------------------------------------------------------------------------
|
||
def force_act2
|
||
target2(@full_action.shift)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 個別処理開始
|
||
#--------------------------------------------------------------------------
|
||
def individual_start
|
||
@individual_targets = @target_battler.dup
|
||
@remain_targets = @target_battler.dup
|
||
@target_battler = [@individual_targets[0]]
|
||
# リピート部分のアクションを保持
|
||
@individual_act = @full_action.dup
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 個別処理終了
|
||
#--------------------------------------------------------------------------
|
||
def individual_end
|
||
@individual_targets.shift
|
||
for target in @individual_targets
|
||
@individual_targets.shift if target.dead?
|
||
end
|
||
# ターゲットが残っているなら行動リピート
|
||
return @target_battler = @remain_targets if @individual_targets.size == 0
|
||
@full_action = @individual_act.dup
|
||
@target_battler = [@individual_targets[0]]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ループ開始
|
||
#--------------------------------------------------------------------------
|
||
def loop_start
|
||
# ループ部分のアクションを保持
|
||
@loop_act = @full_action.dup
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ループ終了
|
||
#--------------------------------------------------------------------------
|
||
def loop_end
|
||
# 行動リピート
|
||
@full_action = @loop_act.dup if @loop_act != []
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 次の行動者へ移行
|
||
#--------------------------------------------------------------------------
|
||
def next_battler
|
||
@action_end = true
|
||
@active = false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 画像変更フラグ
|
||
#--------------------------------------------------------------------------
|
||
def set_change
|
||
@change_up = true
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 戦闘シーン通信
|
||
#--------------------------------------------------------------------------
|
||
def play_data
|
||
data = @play_data
|
||
@play_data = []
|
||
return data
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ショートカットコマンド
|
||
#--------------------------------------------------------------------------
|
||
def anime(anime_id, wait = true)
|
||
@action_data = ["anime",anime_id,1,false,wait,false,true,false]
|
||
end
|
||
def anime_me(anime_id, wait = true)
|
||
@action_data = ["anime",anime_id,0,false,wait,false,true,false]
|
||
end
|
||
def se(file, pitch = 100)
|
||
@action_data = ["sound", "se", pitch, 100, file]
|
||
end
|
||
def target(act)
|
||
for target in @target_battler do target.sv.force_action = act end
|
||
end
|
||
def target2(act)
|
||
for target in @second_targets do target.sv.force_action = act end
|
||
end
|
||
def delay(time)
|
||
@wait = @battler.index * time
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトラーのIDを取得
|
||
#--------------------------------------------------------------------------
|
||
def id
|
||
return @battler.id if @battler.actor?
|
||
return -@battler.id
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 被クリティカルフラグを取得
|
||
#--------------------------------------------------------------------------
|
||
def critical?
|
||
return @battler.result.critical
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 被回復フラグを取得
|
||
#--------------------------------------------------------------------------
|
||
def recovery?
|
||
recovery = false
|
||
recovery = true if @battler.result.hp_damage < 0
|
||
recovery = true if @battler.result.mp_damage < 0
|
||
recovery = true if @battler.result.tp_damage < 0
|
||
return recovery
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 被スキルIDを取得
|
||
#--------------------------------------------------------------------------
|
||
def damage_skill_id
|
||
return @damage_skill_id
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 被アイテムIDを取得
|
||
#--------------------------------------------------------------------------
|
||
def damage_item_id
|
||
return @damage_item_id
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 装備武器を取得
|
||
#--------------------------------------------------------------------------
|
||
def weapon_id
|
||
return 0 if !@battler.weapons[0]
|
||
return @battler.weapons[0].id
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 装備武器のタイプを取得
|
||
#--------------------------------------------------------------------------
|
||
def weapon_type
|
||
return 0 if !@battler.weapons[0]
|
||
return @battler.weapons[0].wtype_id
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 盾を装備しているか
|
||
#--------------------------------------------------------------------------
|
||
def shield?
|
||
for armor in @battler.armors do return true if armor != nil && armor.etype_id == 1 end
|
||
return false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ダメージがあるか
|
||
#--------------------------------------------------------------------------
|
||
def damage_zero?
|
||
return @battler.result.hp_damage == 0 && @battler.result.mp_damage == 0 && @battler.result.tp_damage == 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルIDを取得
|
||
#--------------------------------------------------------------------------
|
||
def skill_id
|
||
return @counter_id if @counter_id != 0
|
||
return 0 if @battler.current_action == nil or @battler.current_action.item == nil
|
||
return 0 if @battler.current_action.item.is_a?(RPG::Item)
|
||
return @battler.current_action.item.id
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキルのタイプを取得
|
||
#--------------------------------------------------------------------------
|
||
def skill_type
|
||
return 0 if skill_id == 0
|
||
return $data_skills[skill_id].stype_id
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキル名を取得
|
||
#--------------------------------------------------------------------------
|
||
def skill_name
|
||
return "" if skill_id == 0
|
||
return $data_skills[skill_id].name
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アイテムIDを取得
|
||
#--------------------------------------------------------------------------
|
||
def item_id
|
||
return 0 if @battler.current_action == nil or @battler.current_action.item == nil
|
||
return @battler.current_action.item.id
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 攻撃アクション
|
||
#--------------------------------------------------------------------------
|
||
def attack_action(item)
|
||
return skill_action if item.is_a?(RPG::Skill)
|
||
return item_action
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ダメージアクションベース
|
||
#--------------------------------------------------------------------------
|
||
def damage_action_base(item)
|
||
@damage_skill_id = 0
|
||
@damage_item_id = 0
|
||
@damage_skill_id = item.id if item.is_a?(RPG::Skill)
|
||
@damage_item_id = item.id if item.is_a?(RPG::Item)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ダメージアクション
|
||
#--------------------------------------------------------------------------
|
||
def damage_action(attacker, item)
|
||
damage_action_base(item)
|
||
act = damage(attacker)
|
||
return if @active
|
||
start_action(act) if act != nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 回避アクション
|
||
#--------------------------------------------------------------------------
|
||
def evasion_action(attacker, item)
|
||
damage_action_base(item)
|
||
act = evasion(attacker)
|
||
return if @active
|
||
start_action(act) if act != nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ミスアクション
|
||
#--------------------------------------------------------------------------
|
||
def miss_action(attacker, item)
|
||
damage_action_base(item)
|
||
act = miss(attacker)
|
||
return if @active
|
||
start_action(act) if act != nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 閃きスクリプト併用処理
|
||
#--------------------------------------------------------------------------
|
||
def flash_action
|
||
return "閃き"
|
||
end
|
||
|
||
end
|
||
|
||
|
||
#==============================================================================
|
||
# ■ module N03
|
||
#------------------------------------------------------------------------------
|
||
# サイドビューバトルのモジュールです。
|
||
#==============================================================================
|
||
module N03
|
||
#--------------------------------------------------------------------------
|
||
# ● バトラーの敵グループを取得
|
||
#--------------------------------------------------------------------------
|
||
def self.get_enemy_unit(battler)
|
||
return $game_troop if battler.actor?
|
||
return $game_party
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトラーの味方グループを取得
|
||
#--------------------------------------------------------------------------
|
||
def self.get_party_unit(battler)
|
||
return $game_party if battler.actor?
|
||
return $game_troop
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 戦闘アニメ時間の取得
|
||
#--------------------------------------------------------------------------
|
||
def self.get_anime_time(anime_id)
|
||
return 0 if anime_id <= 0
|
||
return $data_animations[anime_id].frame_max * 4
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 攻撃アニメの取得
|
||
#--------------------------------------------------------------------------
|
||
def self.get_attack_anime_id(kind, battler)
|
||
return $data_skills[battler.sv.counter_id].animation_id if kind == -3 && battler.sv.counter_id != 0
|
||
case kind
|
||
when -1 ; anime_id = battler.atk_animation_id1
|
||
when -2 ; anime_id = battler.atk_animation_id2
|
||
when -3
|
||
if battler.current_action != nil
|
||
anime_id = battler.current_action.item.animation_id if battler.current_action.item != nil
|
||
end
|
||
else ; anime_id = kind
|
||
end
|
||
case anime_id
|
||
when -1 ; anime_id = battler.atk_animation_id1
|
||
when -2 ; anime_id = battler.atk_animation_id2
|
||
end
|
||
return anime_id if anime_id
|
||
return 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 戦闘アニメデータをセット
|
||
#--------------------------------------------------------------------------
|
||
def self.set_damage_anime_data(targets, target, data)
|
||
return if !first_of_all_screen_anime(data[0], target, targets)
|
||
target.animation_id = data[0]
|
||
target.animation_mirror = data[1]
|
||
target.sv.anime_no_mirror = data[2]
|
||
target.sv.anime_camera_zoom = data[3]
|
||
target.sv.anime_plus_z = data[4]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ターゲットの取得
|
||
#--------------------------------------------------------------------------
|
||
def self.get_targets(kind, battler)
|
||
case kind.abs
|
||
when 0 ; return [battler].dup
|
||
when 1 ; return battler.sv.target_battler.dup
|
||
when 2 ; return get_enemy_unit(battler).members.dup
|
||
when 3 ; return get_party_unit(battler).members.dup
|
||
when 4 ; return $game_troop.members.dup + $game_party.battle_members.dup
|
||
when 5 ; return battler.sv.second_targets.dup
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ターゲットの座標を取得
|
||
#--------------------------------------------------------------------------
|
||
def self.get_targets_position(targets, horming, m_a = nil)
|
||
return [0,0,0] if targets == nil && !$sv_camera.mirror
|
||
return [Graphics.width,0,0] if targets == nil && $sv_camera.mirror
|
||
x = y = h = 0
|
||
for i in 0...targets.size
|
||
x += targets[i].sv.base_x if !horming
|
||
y += targets[i].sv.base_y if !horming
|
||
h += targets[i].sv.base_h if !horming
|
||
x += targets[i].sv.x if horming
|
||
y += targets[i].sv.y if horming
|
||
h += targets[i].sv.h if horming
|
||
y -= targets[i].sv.ch * 100 if m_a == 0
|
||
y -= targets[i].sv.ch * 50 if m_a == 1
|
||
end
|
||
return [x / targets.size, y / targets.size, h / targets.size]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 速度を時間に変換
|
||
#--------------------------------------------------------------------------
|
||
def self.distanse_calculation(time, target_position, self_position, distanse_move)
|
||
return time if !distanse_move
|
||
distanse_x = self_position[0] - target_position[0]
|
||
distanse_x = target_position[0] - self_position[0] if target_position[0] > self_position[0]
|
||
distanse_y = self_position[1] - target_position[1]
|
||
distanse_y = target_position[1] - self_position[1] if target_position[1] > self_position[1]
|
||
if self_position[2] != nil && target_position[2] != nil
|
||
distanse_h = self_position[2] - target_position[2]
|
||
distanse_h = target_position[2] - self_position[2] if target_position[2] > self_position[2]
|
||
else
|
||
distanse_h = 0
|
||
end
|
||
distanse = [distanse_x, distanse_y, distanse_h].max
|
||
return distanse / (time * 100) + 1
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 放物線移動計算
|
||
#--------------------------------------------------------------------------
|
||
def self.parabola(data, time, size, type = 1)
|
||
move_data = data
|
||
move_data[0] *= size
|
||
move_data[1] *= size
|
||
move = []
|
||
move_d = []
|
||
for i in 0...time / 2
|
||
move[i] = move_data[0]
|
||
move_d[i] = move_data[1]
|
||
move_data[0] = move_data[0] * type / (1 + type)
|
||
move_data[1] = move_data[1] * type / (1 + type)
|
||
end
|
||
move = move + move_d.reverse!
|
||
move.reverse!
|
||
adjust = move.inject(0) {|result, item| result + item }
|
||
move[move.size - 1] += adjust if data[0] == data[1] && adjust != 0
|
||
move.unshift(0) if time % 2 != 0
|
||
return move
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 反転値
|
||
#--------------------------------------------------------------------------
|
||
def self.mirror_num(mirror)
|
||
return 1 if !mirror
|
||
return -1
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● カメラワーク
|
||
#--------------------------------------------------------------------------
|
||
def self.camera(battler, data)
|
||
battler = $game_party.battle_members[0] if !battler
|
||
cx = data[2][0] * 100
|
||
cy = data[2][1] * 100
|
||
return $sv_camera.move(cx, cy, data[3], data[4], true) if data[1] == 6
|
||
targets = self.get_targets(data[1], battler)
|
||
return if targets == nil or targets == []
|
||
position = self.get_targets_position(targets, true)
|
||
$sv_camera.move(position[0], position[1] - position[2], data[3], data[4], false)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● コラプス禁止
|
||
#--------------------------------------------------------------------------
|
||
def self.immortaling
|
||
# 全員に不死身付与
|
||
for member in $game_party.battle_members + $game_troop.members
|
||
# イベント操作等で不死身設定になっていたら解除を無効にするフラグを立てる
|
||
member.sv.immortal = true if member.state?(N03::IMMORTAL_ID)
|
||
member.add_state(N03::IMMORTAL_ID)
|
||
end
|
||
return true
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● コラプス許可
|
||
#--------------------------------------------------------------------------
|
||
def self.unimmortaling
|
||
# 全員の不死身化解除(イベント等で不死身設定がされていれば除く)
|
||
for member in $game_party.battle_members + $game_troop.members
|
||
next if member.dead?
|
||
# 不死身ステートが行動中に解除されていた場合、解除無効を解除
|
||
member.sv.immortal = false if !member.state?(N03::IMMORTAL_ID) && member.sv.immortal
|
||
next member.sv.immortal = false if member.sv.immortal
|
||
member.remove_state(N03::IMMORTAL_ID)
|
||
next if member.hp != 0
|
||
member.add_state(1)
|
||
member.perform_collapse_effect
|
||
member.sv.action_terminate
|
||
end
|
||
return false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキル派生
|
||
#--------------------------------------------------------------------------
|
||
def self.derived_skill(battler)
|
||
battler.force_action(battler.sv.derivation_skill_id, -2)
|
||
BattleManager.unshift_action_battlers(battler)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ダメージの作成
|
||
#--------------------------------------------------------------------------
|
||
def self.set_damage(battler, hp_damage, mp_damage)
|
||
battler.result.hp_damage = hp_damage
|
||
battler.result.mp_damage = mp_damage
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ターゲット生死確認
|
||
#--------------------------------------------------------------------------
|
||
def self.targets_alive?(targets)
|
||
return false if targets == []
|
||
for target in targets do return true if !target.dead? end
|
||
return false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ターゲットをセカンドターゲットへ
|
||
#--------------------------------------------------------------------------
|
||
def self.s_targets(battler)
|
||
battler.sv.target_battler = battler.sv.second_targets
|
||
return battler.sv.second_targets
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● セカンドターゲットをターゲットへ
|
||
#--------------------------------------------------------------------------
|
||
def self.targets_set(battler)
|
||
battler.sv.second_targets = battler.current_action.make_targets.compact
|
||
battler.sv.target_battler = battler.sv.second_targets
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 戦闘アニメ実行判定 (対象：画面時は最初のターゲットのみアニメ実行)
|
||
#--------------------------------------------------------------------------
|
||
def self.first_of_all_screen_anime(anime_id, target, targets)
|
||
anime = $data_animations[anime_id]
|
||
return false if !anime
|
||
return true if anime.position != 3
|
||
return false if anime.position == 3 && target != targets[0]
|
||
targets.delete(target)
|
||
target.sv.timing_targets = targets
|
||
return true
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 戦闘不能付加攻撃か
|
||
#--------------------------------------------------------------------------
|
||
def self.dead_attack?(battler, item)
|
||
for state in battler.atk_states
|
||
return true if state == battler.death_state_id
|
||
end
|
||
for effect in item.effects
|
||
return true if effect.code == 21 && effect.data_id == battler.death_state_id
|
||
end
|
||
return false
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Sprite_Weapon
|
||
#------------------------------------------------------------------------------
|
||
# ウエポン表示用のスプライトです。
|
||
#==============================================================================
|
||
class Sprite_Weapon < Sprite_Base
|
||
#--------------------------------------------------------------------------
|
||
# ● 公開インスタンス変数
|
||
#--------------------------------------------------------------------------
|
||
attr_reader :index # ウエポン画像配列のインデックス
|
||
attr_reader :battler # 画像が参照しているバトラー
|
||
attr_reader :move_time # 画像が目標に到達するまでの時間
|
||
attr_reader :through # 貫通フラグ
|
||
attr_reader :action_end # 武器アクション終了フラグ
|
||
attr_reader :action_end_cancel # 武器アクション終了フラグ
|
||
attr_reader :hit_position # 画像が目標に到達した時の座標
|
||
attr_accessor :hit_anime_id # 画像が目標に到達した時のアニメID
|
||
#--------------------------------------------------------------------------
|
||
# ● オブジェクト初期化
|
||
#--------------------------------------------------------------------------
|
||
def initialize(viewport, index, battler)
|
||
super(viewport)
|
||
@index = index
|
||
@battler = battler
|
||
@position_x = @position_y = 0
|
||
@o = 0
|
||
@real_x = @real_y = 0
|
||
@mirror = @battler.sv.mirror
|
||
reset
|
||
set_action
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 初期化
|
||
#--------------------------------------------------------------------------
|
||
def reset
|
||
@z_plus = 0
|
||
@weapon_data = []
|
||
@move_data = []
|
||
@move_x = 0
|
||
@move_y = 0
|
||
@orbit = []
|
||
@through = false
|
||
@distanse_move = false
|
||
@weapon_width = 0
|
||
@weapon_height = 0
|
||
@anime_time = 0
|
||
@anime_position = 1
|
||
@move_time = 0
|
||
@hit_anime_id = 0
|
||
@move_anime = true
|
||
@action_end = false
|
||
@action_end_cancel = false
|
||
reset_position
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アクションをセット
|
||
#--------------------------------------------------------------------------
|
||
def set_action
|
||
return if @battler.sv.effect_data == []
|
||
weapon_anime if @battler.sv.effect_data[0][0] == "wp"
|
||
move_anime if @battler.sv.effect_data[0][0] == "m_a"
|
||
@battler.sv.effect_data.shift
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 武器アニメ実行
|
||
#--------------------------------------------------------------------------
|
||
def weapon_anime
|
||
@weapon_data = @battler.sv.effect_data[0].dup
|
||
set_graphics
|
||
set_ox
|
||
set_weapon_move
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アニメ移動実行
|
||
#--------------------------------------------------------------------------
|
||
def move_anime
|
||
@move_data = @battler.sv.effect_data[0].dup
|
||
# ターゲットを取得
|
||
@target_battler = [@battler.sv.m_a_targets.shift]
|
||
@target_battler = N03.get_targets(@move_data[3], @battler) if @move_data[3] < 0
|
||
set_move
|
||
return if @move_data[16] == ""
|
||
weapon_data = N03::ACTION[@move_data[16]]
|
||
return if weapon_data == nil
|
||
@weapon_data = weapon_data.dup
|
||
set_graphics
|
||
set_ox
|
||
set_weapon_move
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 武器画像を取得
|
||
#--------------------------------------------------------------------------
|
||
def set_graphics
|
||
# 武器に依存しない画像設定がある場合
|
||
if @weapon_data[13] != ""
|
||
self.bitmap = Cache.character(@weapon_data[13]).dup
|
||
@weapon_width = self.bitmap.width
|
||
@weapon_height = self.bitmap.height
|
||
return
|
||
end
|
||
# 武器を取得
|
||
weapon = @battler.weapons[0]
|
||
# 逆手装備を取得
|
||
if @weapon_data[10]
|
||
weapon = nil
|
||
for armor in @battler.armors do break weapon = armor if armor.is_a?(RPG::Armor) && armor.etype_id == 1 end
|
||
weapon = @battler.weapons[1] if !weapon
|
||
end
|
||
# 武器がなければ処理をキャンセル
|
||
return if weapon == nil
|
||
# インデックスを取得
|
||
file_index = @weapon_data[12]
|
||
# アイコンを利用するなら
|
||
if @weapon_data[1] == 0
|
||
icon_index = weapon.icon_index
|
||
self.bitmap = Cache.system("Iconset" + file_index).dup
|
||
self.src_rect.set(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
|
||
@weapon_width = @weapon_height = 24
|
||
# 独自画像指定
|
||
else
|
||
file_name = @battler.sv.weapon_graphic(weapon.id, weapon.wtype_id) if weapon.is_a?(RPG::Weapon)
|
||
file_name = @battler.sv.shield_graphic(weapon.id, weapon.atype_id) if weapon.is_a?(RPG::Armor)
|
||
self.bitmap = Cache.character(file_name + file_index).dup
|
||
@weapon_width = self.bitmap.width
|
||
@weapon_height = self.bitmap.height
|
||
return if @weapon_data[1] == 1
|
||
# 2003仕様の武器アニメ
|
||
@weapon_width /= @battler.sv.max_pattern[0]
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 画像の原点を取得
|
||
#--------------------------------------------------------------------------
|
||
def set_ox
|
||
# 反転時は設定を逆に
|
||
if @mirror
|
||
case @weapon_data[6]
|
||
when 1 ; @weapon_data[6] = 2 # 左上→右上に
|
||
when 2 ; @weapon_data[6] = 1 # 右上→左上に
|
||
when 3 ; @weapon_data[6] = 4 # 左下→右下に
|
||
when 4 ; @weapon_data[6] = 3 # 右下→左下に
|
||
end
|
||
end
|
||
# 原点を設定
|
||
case @weapon_data[6]
|
||
when 0 # 中心
|
||
self.ox = @weapon_width / 2
|
||
self.oy = @weapon_height / 2
|
||
when 1 # 左上
|
||
self.ox = 0
|
||
self.oy = 0
|
||
when 2 # 右上
|
||
self.ox = @weapon_width
|
||
self.oy = 0
|
||
when 3 # 左下
|
||
self.ox = 0
|
||
self.oy = @weapon_height
|
||
when 4 # 右下
|
||
self.ox = @weapon_width
|
||
self.oy = @weapon_height
|
||
when 5 # バトラーと同じ
|
||
self.ox = @weapon_width / 2
|
||
self.oy = @weapon_height
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトラーの座標を取得
|
||
#--------------------------------------------------------------------------
|
||
def set_battler_position
|
||
@position_x = @battler.sv.x + @weapon_data[3][0] * N03.mirror_num(@mirror) * 100
|
||
@position_y = (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.c - @battler.sv.oy_adjust) + @weapon_data[3][1] * 100#紅茶走
|
||
reset_position
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 座標を初期化
|
||
#--------------------------------------------------------------------------
|
||
def reset_position
|
||
@real_x = @position_x / 100
|
||
@real_y = @position_y / 100
|
||
@real_zoom_x = 1
|
||
@real_zoom_y = 1
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 戦闘アニメを表示
|
||
#--------------------------------------------------------------------------
|
||
def set_animation(anime_id)
|
||
return if $data_animations[anime_id] == nil
|
||
@anime_position = $data_animations[anime_id].position
|
||
@horming = true
|
||
@horming = false if @anime_position == 3
|
||
@anime_camera_zoom = true
|
||
@anime_no_mirror = false
|
||
start_animation($data_animations[anime_id], @mirror)
|
||
timings = $data_animations[anime_id].timings
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ヒット時の戦闘アニメ実行
|
||
#--------------------------------------------------------------------------
|
||
def set_hit_animation(position_data, hit_anime_id, target)
|
||
return if $data_animations[hit_anime_id] == nil
|
||
@real_x = position_data[0]
|
||
@real_y = position_data[1]
|
||
@position_x = position_data[0] * 100
|
||
@position_y = position_data[1] * 100
|
||
self.z = position_data[2]
|
||
@z_plus = 1000
|
||
@action_end = false
|
||
@horming = true
|
||
set_animation(hit_anime_id)
|
||
@anime_time = $data_animations[hit_anime_id].frame_max * 4
|
||
@timing_targets = [target]
|
||
@move_time = @hit_anime_id = 0
|
||
@weapon_data = []
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● タイミングバトラー追加
|
||
#--------------------------------------------------------------------------
|
||
def timing_battler_set(target)
|
||
@timing_targets.push(target)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 武器の動きを取得
|
||
#--------------------------------------------------------------------------
|
||
def set_weapon_move
|
||
# 開始位置を取得
|
||
set_battler_position if @move_time == 0
|
||
@z_plus = 50 if @z_plus == 0 && @weapon_data[9]
|
||
self.z = @battler.sv.z + @z_plus
|
||
# 反転処理
|
||
@mirror = !@mirror if @weapon_data[7]
|
||
self.mirror = @mirror
|
||
# 更新パターンをセット
|
||
set_pattern
|
||
@max_pattern = 2 if @max_pattern == 1
|
||
# 動きを計算
|
||
@weapon_move_data = []
|
||
@weapon_angle_data = []
|
||
@weapon_zoom_data = []
|
||
num = N03.mirror_num(@mirror)
|
||
for i in 0...@max_pattern
|
||
move_data_x = @weapon_data[2][0] * num * 100 * i / (@max_pattern - 1)
|
||
move_data_y = @weapon_data[2][1] * 100 * i / (@max_pattern - 1)
|
||
move_angle = @weapon_data[4] * num + (@weapon_data[5] * num - @weapon_data[4] * num) * i / (@max_pattern - 1)
|
||
move_zoom_x = 1 + (@weapon_data[8][0] - 1) * i / (@max_pattern - 1)
|
||
move_zoom_y = 1 + (@weapon_data[8][1] - 1) * i / (@max_pattern - 1)
|
||
@weapon_move_data.push([move_data_x, move_data_y])
|
||
@weapon_angle_data.push(move_angle)
|
||
@weapon_zoom_data.push([move_zoom_x, move_zoom_y])
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 更新パターン
|
||
#--------------------------------------------------------------------------
|
||
def set_pattern
|
||
if @weapon_data[11] == -1
|
||
return @max_pattern = @battler.sv.max_pattern[0] if @battler.sv.pattern_type != 0
|
||
@count = @battler.sv.pattern_time
|
||
@max_count = @battler.sv.pattern_time
|
||
@max_pattern = @battler.sv.max_pattern[0]
|
||
@repeat = false
|
||
else
|
||
@count = @weapon_data[11][0]
|
||
@max_count = @weapon_data[11][0]
|
||
@max_pattern = @weapon_data[11][1]
|
||
@repeat = @weapon_data[11][2]
|
||
end
|
||
@pattern = 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 移動実行
|
||
#--------------------------------------------------------------------------
|
||
def set_move
|
||
# 戦闘アニメを取得
|
||
set_animation(@move_data[1][0]) if $data_animations[@move_data[1][0]] != nil && $data_animations[@move_data[1][0]].position != 3
|
||
@anime_camera_zoom = @move_data[13]
|
||
@loop = @move_data[14]
|
||
@loop = false if @move_data[1][0] == 0
|
||
@anime_no_mirror = @move_data[15]
|
||
@se_flag = @move_data[17]
|
||
# 開始位置を取得
|
||
start_position
|
||
@z_plus = 1000 if @move_data[9]
|
||
# ターゲットバトラー画像にこのアニメのSEとタイミング設定を反映させる
|
||
@timing_targets = @target_battler
|
||
# 座標計算
|
||
@move_x = @move_data[5][0] * 100 * N03.mirror_num(@mirror)
|
||
@move_y = @move_data[5][1] * 100
|
||
# 時間計算か速度計算か
|
||
@distanse_move = true if @move_data[6] > 0
|
||
@move_time = @move_data[6].abs
|
||
# 時間0の場合、アニメが設定されていればアニメ表示時間に合わせる
|
||
if @move_time == 0
|
||
@move_time = $data_animations[@move_data[1][0]].frame_max * 4 if $data_animations[@move_data[1][0]]
|
||
@move_time = 1 if !$data_animations[@move_data[1][0]]
|
||
@distanse_move = false
|
||
end
|
||
# 貫通タイプの場合
|
||
@through = true if @move_data[7] == 1
|
||
@auto_through_flag = false
|
||
@auto_through_flag = true if @move_data[7] == 0
|
||
# ターゲット座標計算
|
||
if @target_battler == nil
|
||
@target_x = @move_x * 100
|
||
@target_x = (Graphics.width - @move_x) * 100 if @mirror
|
||
@target_y = @move_y * 100
|
||
else
|
||
move_data_set
|
||
end
|
||
# ターゲットに到達するまでの時間を計算
|
||
@move_time = distanse_calculation(@move_time, @target_x, @target_y)
|
||
# 円軌道計算
|
||
orbit
|
||
# バトラーのウエイト設定
|
||
@battler.sv.wait = @move_time - 1 if @move_data[10][0]
|
||
@move_horming = @move_data[12]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 速度を時間に変換
|
||
#--------------------------------------------------------------------------
|
||
def distanse_calculation(time, target_x, target_y)
|
||
return time if !@distanse_move
|
||
distanse_x = @position_x - @target_x
|
||
distanse_x = @target_x - @position_x if @target_x > @position_x
|
||
distanse_y = @position_y - @target_y
|
||
distanse_y = @target_y - @position_y if @target_y > @position_y
|
||
distanse = [distanse_x, distanse_y].max
|
||
return distanse / (time * 100) + 1
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 移動目標の更新
|
||
#--------------------------------------------------------------------------
|
||
def move_data_set
|
||
return if @target_battler == nil
|
||
position = N03.get_targets_position(@target_battler, true, @anime_position)
|
||
@target_x = position[0] + @move_x
|
||
@target_y = position[1] - position[2] + @move_y
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 開始位置を計算
|
||
#--------------------------------------------------------------------------
|
||
def start_position
|
||
starter = [@battler.sv.m_a_starter.shift]
|
||
starter = N03.get_targets(@move_data[2], @battler) if @move_data[2] < 0
|
||
position = [0, 0]
|
||
position = N03.get_targets_position(starter, true, @anime_position) if starter != nil
|
||
@position_x = position[0] + @move_data[4][0] * 100
|
||
@position_y = position[1] + position[2] + @move_data[4][1] * 100
|
||
@position_z = @position_y
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 円軌道計算
|
||
#--------------------------------------------------------------------------
|
||
def orbit
|
||
orbit_data = @move_data[8].dup
|
||
orbit_data[0] *= 100
|
||
orbit_data[1] *= 100
|
||
orbit_d = []
|
||
for i in 0...@move_time / 2
|
||
@orbit[i] = orbit_data[0]
|
||
orbit_data[0] /= 2
|
||
orbit_d[i] = orbit_data[1]
|
||
orbit_data[1] /= 2
|
||
end
|
||
@orbit = @orbit + orbit_d.reverse!
|
||
@orbit.reverse!
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● フレーム更新
|
||
#--------------------------------------------------------------------------
|
||
def update
|
||
update_hit_anime if @anime_time != 0
|
||
update_move if @move_time != 0
|
||
update_weapon_move if @weapon_data != []
|
||
update_position
|
||
update_color
|
||
self.visible = @battler.sv.weapon_visible
|
||
super
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ヒット時の戦闘アニメ
|
||
#--------------------------------------------------------------------------
|
||
def update_hit_anime
|
||
@anime_time -= 1
|
||
@action_end = true if @anime_time == 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 移動の更新
|
||
#--------------------------------------------------------------------------
|
||
def update_move
|
||
move_data_set if @move_horming && !@hit_position
|
||
through_set(@move_time, @target_x, @target_y) if @move_time == 1 && !@hit_position
|
||
@o += @orbit[@move_time - 1] if @orbit[@move_time - 1] != nil
|
||
@position_x = (@position_x * (@move_time - 1) + @target_x) / @move_time
|
||
@position_y = (@position_y * (@move_time - 1) + @target_y) / @move_time + @o
|
||
reset_position
|
||
set_animation(@move_data[1][0]) if @loop && !animation?
|
||
@move_time -= 1
|
||
return if @move_time != 0
|
||
@action_end = true if !@action_end_cancel
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 武器の動きを更新
|
||
#--------------------------------------------------------------------------
|
||
def update_weapon_move
|
||
pattern = update_pattern
|
||
set_battler_position if @move_time == 0 && !@action_end_cancel
|
||
@real_x = @position_x / 100 + @weapon_move_data[pattern][0] / 100
|
||
@real_y = @position_y / 100 + @weapon_move_data[pattern][1] / 100
|
||
@real_zoom_x = @weapon_zoom_data[pattern][0]
|
||
@real_zoom_y = @weapon_zoom_data[pattern][1]
|
||
self.angle = @weapon_angle_data[pattern]
|
||
self.src_rect.set(@weapon_width * pattern, 0, @weapon_width, @weapon_height) if @weapon_data[1] == 2
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● パターンを更新
|
||
#--------------------------------------------------------------------------
|
||
def update_pattern
|
||
return @battler.sv.pattern_w if @count == nil
|
||
@count -= 1
|
||
return @pattern if @count != 0
|
||
@count = @max_count
|
||
@pattern += 1
|
||
if !@repeat && @pattern == @max_pattern
|
||
@pattern = @max_pattern - 1
|
||
elsif @pattern == @max_pattern
|
||
@pattern = 0
|
||
end
|
||
return @pattern
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 座標を更新
|
||
#--------------------------------------------------------------------------
|
||
def update_position
|
||
self.x = (@real_x - $sv_camera.x) * $sv_camera.convert / 1000
|
||
self.y = (@real_y - $sv_camera.y) * $sv_camera.convert / 1000
|
||
self.x += $sv_camera.sx / 100 unless @battler.sv.h != 0 && @weapon_data != []
|
||
self.y += $sv_camera.sy / 100 unless @battler.sv.h != 0 && @weapon_data != []
|
||
self.z = @battler.sv.z + @z_plus - 10
|
||
self.zoom_x = @real_zoom_x * $sv_camera.zoom
|
||
self.zoom_y = @real_zoom_y * $sv_camera.zoom
|
||
self.opacity = @battler.sv.opacity if @battler.sv.opacity_data[4]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 貫通の処理
|
||
#--------------------------------------------------------------------------
|
||
def through_set(time, target_x, target_y)
|
||
@hit_anime_id = N03.get_attack_anime_id(@move_data[1][1], @battler)
|
||
@battler.sv.wait = N03.get_anime_time(@hit_anime_id) if @move_data[10][1]
|
||
moving_x = (target_x / 100 - @position_x / 100) / time
|
||
moving_y = (target_y / 100 - @position_y / 100) / time
|
||
goal_x = $sv_camera.max_left - 100 if moving_x < 0
|
||
goal_x = Graphics.width + $sv_camera.max_right + 100 if moving_x > 0
|
||
goal_y = $sv_camera.max_top - 100 if moving_y < 0
|
||
goal_y = Graphics.height + $sv_camera.max_bottom + 100 if moving_y > 0
|
||
if goal_x == nil && goal_y == nil
|
||
time = 0
|
||
reset_position
|
||
else
|
||
time = move_calculation(moving_x, moving_y, goal_x, goal_y)
|
||
end
|
||
target_x = @position_x + moving_x * time * 100
|
||
target_y = @position_y + moving_y * time * 100
|
||
@pre_data = [time, target_x, target_y]
|
||
@battler.sv.m_a_data.push([@move_data[11], @target_battler, @index, @auto_through_flag, []])
|
||
@action_end_cancel = true
|
||
@hit_position = [@real_x, @real_y, self.z]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 到達時間試算
|
||
#--------------------------------------------------------------------------
|
||
def move_calculation(moving_x, moving_y, goal_x, goal_y)
|
||
move_x = @position_x / 100
|
||
move_y = @position_y / 100
|
||
time = 0
|
||
loop do
|
||
move_x += moving_x
|
||
move_y += moving_y
|
||
time += 1
|
||
return time if moving_x < 0 && move_x < goal_x
|
||
return time if moving_x > 0 && move_x > goal_x
|
||
return time if moving_y < 0 && move_y < goal_y
|
||
return time if moving_y > 0 && move_y > goal_y
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ミス時に消える処理から貫通処理に変換
|
||
#--------------------------------------------------------------------------
|
||
def through_change
|
||
@action_end_cancel = false
|
||
@through = true
|
||
@move_time = @pre_data[0]
|
||
@target_x = @pre_data[1]
|
||
@target_y = @pre_data[2]
|
||
@pre_data = nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● SE とフラッシュのタイミング処理
|
||
#--------------------------------------------------------------------------
|
||
def animation_process_timing(timing)
|
||
return if !@timing_targets
|
||
se_flag = true
|
||
se_flag = @se_flag if @se_flag != nil
|
||
for target in @timing_targets
|
||
target.sv.timing.push([se_flag, timing.dup])
|
||
se_flag = false if @animation.position == 3
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 色調の更新
|
||
#--------------------------------------------------------------------------
|
||
def update_color
|
||
return if @battler.sv.color == []
|
||
self.color.set(@battler.sv.color[0], @battler.sv.color[1], @battler.sv.color[2], @battler.sv.color[3])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 解放
|
||
#--------------------------------------------------------------------------
|
||
def dispose
|
||
super
|
||
self.bitmap.dispose if self.bitmap != nil
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Sprite_Battle_Picture
|
||
#------------------------------------------------------------------------------
|
||
# ピクチャ表示用のスプライトです。
|
||
#==============================================================================
|
||
class Sprite_Battle_Picture < Sprite
|
||
#--------------------------------------------------------------------------
|
||
# ● 公開インスタンス変数
|
||
#--------------------------------------------------------------------------
|
||
attr_accessor :action_end # 終了フラグ
|
||
#--------------------------------------------------------------------------
|
||
# ● オブジェクト初期化
|
||
#--------------------------------------------------------------------------
|
||
def initialize(viewport = nil)
|
||
super(viewport)
|
||
@action_end = false
|
||
self.ox = 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● セット
|
||
#--------------------------------------------------------------------------
|
||
def set(battler)
|
||
@battler = battler
|
||
@data = @battler.sv.effect_data.shift
|
||
@time = @data[4]
|
||
@mirror = $sv_camera.mirror
|
||
@mirror = false if !@data[8]
|
||
self.opacity = @data[6][0]
|
||
@s_x = @data[2][0] if @data[2] != []
|
||
@s_x = Graphics.width - @data[2][0] if @data[2] != [] && @mirror
|
||
@s_y = @data[2][1] if @data[2] != []
|
||
@e_x = @data[3][0] if @data[3] != []
|
||
@e_x = Graphics.width - @data[3][0] if @data[3] != [] && @mirror
|
||
@e_y = @data[3][1] if @data[3] != []
|
||
@s_x = self.x if @data[2] == []
|
||
@s_y = self.y if @data[2] == []
|
||
@e_x = self.x if @data[3] == []
|
||
@e_y = self.y if @data[3] == []
|
||
self.x = @s_x
|
||
self.y = @s_y
|
||
return @action_end = true if @time == 0
|
||
@move_x = (@e_x * 1.0 - @s_x) / @time
|
||
@move_y = (@e_y * 1.0 - @s_y) / @time
|
||
self.z = @data[5]
|
||
return set_plane(battler) if @data[7] != []
|
||
self.bitmap = Cache.picture(@data[9]) if !bitmap or @data[9] != ""
|
||
return @action_end = true if !bitmap
|
||
self.mirror = @mirror
|
||
self.ox = self.bitmap.width if @mirror
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● プレーン移行
|
||
#--------------------------------------------------------------------------
|
||
def set_plane(battler)
|
||
@viewport = Viewport.new(@data[2][0],@data[2][1],@data[7][0],@data[7][1]) if !@viewport
|
||
viewport = @viewport
|
||
@plane = Plane.new(viewport) if !@plane
|
||
@plane.bitmap = Cache.picture(@data[9]) if !@plane.bitmap or @data[9] != ""
|
||
return @action_end = true if !@plane.bitmap
|
||
@plane.ox = @data[7][0]
|
||
@plane.oy = @data[7][1]
|
||
@plane.opacity = @data[6][0]
|
||
@move_x = @remain_move[0] if @data[2] == @data[3]
|
||
@move_y = @remain_move[1] if @data[2] == @data[3]
|
||
@remain_move = [@move_x, @move_y]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● フレーム更新
|
||
#--------------------------------------------------------------------------
|
||
def update
|
||
@action_end = true if !@battler.sv.picture
|
||
return if @time == 0
|
||
return if @action_end
|
||
@time -= 1
|
||
return plane_update if @plane
|
||
super
|
||
self.x += @move_x
|
||
self.y += @move_y
|
||
self.opacity += @data[6][1]
|
||
return if @time != 1
|
||
self.x = @e_x
|
||
self.y = @e_y
|
||
@time = 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● フレーム更新
|
||
#--------------------------------------------------------------------------
|
||
def plane_update
|
||
@plane.ox += @move_x
|
||
@plane.oy += @move_y
|
||
@plane.opacity += @data[6][1]
|
||
@time = @data[4] if @time == 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 解放
|
||
#--------------------------------------------------------------------------
|
||
def dispose
|
||
bitmap.dispose if bitmap
|
||
@plane.dispose if @plane
|
||
@viewport.dispose if @viewport
|
||
super
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Sprite_Back_Picture
|
||
#------------------------------------------------------------------------------
|
||
# 周期ピクチャ用のスプライトです。
|
||
#==============================================================================
|
||
class Sprite_Back_Picture < Plane
|
||
#--------------------------------------------------------------------------
|
||
# ● 公開インスタンス変数
|
||
#--------------------------------------------------------------------------
|
||
attr_accessor :action_end # 終了フラグ
|
||
#--------------------------------------------------------------------------
|
||
# ● オブジェクト初期化
|
||
#--------------------------------------------------------------------------
|
||
def initialize(viewport = nil, index)
|
||
super(viewport)
|
||
@index = index
|
||
@real_x = 0
|
||
@real_y = 0
|
||
@real_opacity = 0
|
||
@move_x = 0
|
||
@move_y = 0
|
||
@move_opacity = 0
|
||
@time = 0
|
||
@switche = 0
|
||
@action_end = false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● セットアップ
|
||
#--------------------------------------------------------------------------
|
||
def setup(data)
|
||
self.bitmap = Cache.picture(data[9])
|
||
self.z = data[6]
|
||
@switche = data[1]
|
||
mirror = $sv_camera.mirror
|
||
mirror = false if !data[8]
|
||
@move_x = data[3][0]
|
||
@move_x *= -1 if mirror
|
||
@move_y = data[3][1]
|
||
@time = data[4]
|
||
@time = -1 if @time == 0
|
||
@real_opacity = (data[5][0] + 1) * 100
|
||
@move_opacity = data[5][1]
|
||
@start_opacity = data[5][0]
|
||
@shake_ok = data[7]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● フレーム更新
|
||
#--------------------------------------------------------------------------
|
||
def update
|
||
update_picture if @time != 0
|
||
self.ox = $sv_camera.x - @real_x
|
||
self.oy = $sv_camera.y - @real_y
|
||
if @shake_ok
|
||
self.ox -= $sv_camera.sx / 100
|
||
self.oy -= $sv_camera.sy / 100
|
||
end
|
||
self.ox *= $sv_camera.zoom
|
||
self.oy *= $sv_camera.zoom
|
||
self.zoom_x = @zoom_x * $sv_camera.zoom
|
||
self.zoom_y = @zoom_y * $sv_camera.zoom
|
||
self.opacity = @real_opacity / 100
|
||
@move_opacity *= -1 if self.opacity == 255 or self.opacity <= @start_opacity
|
||
@switche
|
||
@action_end = true if @switche > 0 && !$game_switches[@switche]
|
||
@action_end = true if @switche < 0 && !$sv_camera.switches[@switche.abs]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ピクチャの更新
|
||
#--------------------------------------------------------------------------
|
||
def update_picture
|
||
@real_x += @move_x / 100
|
||
@real_y += @move_y / 100
|
||
@real_x = 0 if @real_x >= self.bitmap.width or @real_x <= -self.bitmap.width
|
||
@real_y = 0 if @real_y >= self.bitmap.height or @real_y <= -self.bitmap.height
|
||
@zoom_x = 1
|
||
@zoom_y = 1
|
||
@real_opacity += @move_opacity
|
||
@time -= 1
|
||
@time = -1 if @time < -100
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Sprite_Back_Picture
|
||
#------------------------------------------------------------------------------
|
||
# ダメージ表示のスプライトです。
|
||
#==============================================================================
|
||
class Sprite_Damage < Sprite
|
||
#--------------------------------------------------------------------------
|
||
# ● 公開インスタンス変数
|
||
#--------------------------------------------------------------------------
|
||
attr_reader :action_end # POP終了フラグ
|
||
#--------------------------------------------------------------------------
|
||
# ● オブジェクト初期化
|
||
#--------------------------------------------------------------------------
|
||
def initialize(viewport = nil, battler)
|
||
super(viewport)
|
||
@battler = battler
|
||
@time = 0
|
||
return @action_end = true if !@battler
|
||
@direction = -1
|
||
@direction *= -1 if @battler.actor?
|
||
@direction *= -1 if $sv_camera.mirror
|
||
set_state
|
||
set_damage
|
||
update
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ステート表示
|
||
#--------------------------------------------------------------------------
|
||
def set_state
|
||
return if !N03::STATE_POP
|
||
states = @battler.result.added_state_objects
|
||
states.delete($data_states[@battler.death_state_id]) if @battler.result.hp_damage != 0
|
||
return if states == []
|
||
return if @battler.sv.add_state == @battler.result.added_state_objects
|
||
@battler.sv.add_state = states.dup
|
||
@st = []
|
||
@st_base = []
|
||
for i in 0...states.size
|
||
@st[i] = Sprite.new
|
||
bitmap_state(@st[i], states[i])
|
||
@st_base[i] = []
|
||
@st_base[i][0] = @direction * (-20 + 5 * i) + @battler.sv.x / 100
|
||
@st_base[i][1] = -40 - @state_height * i + (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.oy_adjust)/ 150#紅茶走
|
||
@st[i].z = 1000 + i
|
||
@st[i].opacity = 0
|
||
end
|
||
@time = @pop_time = 80
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ステート画像
|
||
#--------------------------------------------------------------------------
|
||
def bitmap_state(state, state_object)
|
||
name = state_object.name
|
||
state.bitmap = Cache.system("Iconset").dup
|
||
state.src_rect.set(state_object.icon_index % 16 * 24, state_object.icon_index / 16 * 24, 24, 24)
|
||
@state_height = 24
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ダメージ表示
|
||
#--------------------------------------------------------------------------
|
||
def hit_count
|
||
for i in 0...@battler.sv.hit.size
|
||
if @battler.sv.hit[i] == nil
|
||
@hit = i
|
||
return @battler.sv.hit[i] = @hit
|
||
end
|
||
end
|
||
@hit = @battler.sv.hit.size
|
||
@battler.sv.hit.push(@hit)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ダメージ表示
|
||
#--------------------------------------------------------------------------
|
||
def set_damage
|
||
return @action_end = true if !N03::DAMAGE_POP
|
||
damage = @battler.result.hp_damage if @battler.result.hp_damage != 0
|
||
damage = @battler.result.hp_drain if @battler.result.hp_drain != 0
|
||
damage = @battler.result.mp_damage if @battler.result.mp_damage != 0
|
||
damage = @battler.result.mp_drain if @battler.result.mp_drain != 0
|
||
damage = @battler.result.tp_damage if @battler.result.tp_damage != 0
|
||
if !damage or damage == 0
|
||
@action_end = true if @st == nil
|
||
return # ステートだけPOPする設定を考慮して@action_endは返さない
|
||
end
|
||
hit_count
|
||
#@hit = @battler.sv.hit
|
||
#@battler.sv.hit += 1 if damage != 0
|
||
file = N03::DAMAGE_PLUS if damage > 0
|
||
file = N03::DAMAGE_MINUS if damage < 0
|
||
add_file = N03::DAMAGE_MP if @battler.result.mp_damage != 0
|
||
add_file = N03::DAMAGE_TP if @battler.result.tp_damage != 0
|
||
adjust_x = N03::DAMAGE_ADJUST
|
||
@num = []
|
||
@num_base = []
|
||
damage = damage.abs
|
||
max_num = damage.to_s.size
|
||
max_num += 1 if add_file != nil
|
||
for i in 0...max_num
|
||
@num[i] = Sprite.new
|
||
if add_file != nil && i == max_num - 1
|
||
@num[i].bitmap = Cache.system(add_file)
|
||
cw = (damage % (10 * 10 ** i))/(10 ** i)
|
||
sw = 0 if sw == nil
|
||
else
|
||
@num[i].bitmap = Cache.system(file)
|
||
cw = (damage % (10 * 10 ** i))/(10 ** i)
|
||
sw = @num[i].bitmap.width / 10
|
||
@num[i].src_rect.set(cw * sw, 0, sw, @num[i].bitmap.height)
|
||
end
|
||
@num_base[i] = []
|
||
@num_base[i][0] = (sw + adjust_x) * i * -1 + (@battler.sv.x / 100)
|
||
@num_base[i][1] = -(@num[i].bitmap.height / 3) - i * 2 - @hit * 2 + (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.oy_adjust)/ 150#紅茶走
|
||
@num_base[i][0] -= @num[i].bitmap.width / 2 - adjust_x if add_file != nil && i == max_num - 1
|
||
@num[i].z = 1000 + i + @hit * 10
|
||
end
|
||
@time = @pop_time = 80
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● フレーム更新
|
||
#--------------------------------------------------------------------------
|
||
def update
|
||
return if @time == 0
|
||
for i in 0...@st.size do update_state_move(@st[i], i) end if @st != nil
|
||
for i in 0...@num.size do update_num_move(@num[i], i) end if @num != nil
|
||
@time -= 1
|
||
@action_end = true if @time == 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ステート画像の更新
|
||
#--------------------------------------------------------------------------
|
||
def update_state_move(state, index)
|
||
min = @pop_time - index * 2
|
||
case @time
|
||
when min-15..min
|
||
@st_base[index][0] += @direction
|
||
state.opacity += 25
|
||
when min-80..min-50
|
||
@st_base[index][0] += @direction
|
||
state.opacity -= 25
|
||
end
|
||
state.x = (@st_base[index][0] - $sv_camera.x) * $sv_camera.zoom
|
||
state.y = (@st_base[index][1] - $sv_camera.y) * $sv_camera.zoom
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 数値の更新
|
||
#--------------------------------------------------------------------------
|
||
def update_num_move(num, index)
|
||
min = @pop_time - index * 2
|
||
case @time
|
||
when min-1..min
|
||
@num_base[index][0] += @direction * @hit
|
||
@num_base[index][1] -= 5 + @hit * 2
|
||
when min-3..min-2
|
||
@num_base[index][0] += @direction * @hit
|
||
@num_base[index][1] -= 4 + @hit * 2
|
||
when min-6..min-4
|
||
@num_base[index][0] += @direction
|
||
@num_base[index][1] -= 3 + @hit * 2
|
||
when min-14..min-7
|
||
@num_base[index][0] += @direction
|
||
@num_base[index][1] += 2
|
||
when min-17..min-15
|
||
@num_base[index][1] -= 2 + @hit * 2
|
||
when min-23..min-18
|
||
@num_base[index][1] += 1
|
||
when min-27..min-24
|
||
@num_base[index][1] -= 1
|
||
when min-30..min-28
|
||
@num_base[index][1] += 1
|
||
when min-33..min-31
|
||
@num_base[index][1] -= 1
|
||
when min-36..min-34
|
||
@num_base[index][1] += 1
|
||
end
|
||
num.x = (@num_base[index][0] - $sv_camera.x) * $sv_camera.zoom
|
||
num.y = (@num_base[index][1] - $sv_camera.y) * $sv_camera.zoom
|
||
num.opacity = 256 - (12 - @time) * 32
|
||
num.visible = false if @time == 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 解放
|
||
#--------------------------------------------------------------------------
|
||
def dispose
|
||
@battler.sv.hit[@hit] = nil if @hit
|
||
bitmap.dispose if bitmap
|
||
for i in 0...@num.size do @num[i].dispose end if @num != nil
|
||
for i in 0...@st.size do @st[i].dispose end if @st != nil
|
||
super
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Window_Skill_name
|
||
#------------------------------------------------------------------------------
|
||
# スキル名を表示するウィンドウです。
|
||
#==============================================================================
|
||
class Window_Skill_name < Window_Base
|
||
#--------------------------------------------------------------------------
|
||
# ● オブジェクト初期化
|
||
#--------------------------------------------------------------------------
|
||
def initialize(text)
|
||
super(0, 0, Graphics.width, line_height + standard_padding * 2)
|
||
draw_text(4, 0, Graphics.width - 64, line_height,text, 1)
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Spriteset_Sideview
|
||
#------------------------------------------------------------------------------
|
||
# サイドビュー独自のスプライトをまとめたクラスです。
|
||
#==============================================================================
|
||
class Spriteset_Sideview
|
||
#--------------------------------------------------------------------------
|
||
# ● オブジェクト初期化
|
||
#--------------------------------------------------------------------------
|
||
def initialize(viewport)
|
||
@viewport = viewport
|
||
@weapons = []
|
||
@pictures = []
|
||
@back_pic = []
|
||
@damage = []
|
||
$sv_camera.setup
|
||
N03.camera(nil, N03::BATTLE_CAMERA["ターン開始前"].dup)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● フレーム更新
|
||
#--------------------------------------------------------------------------
|
||
def update
|
||
update_battler_data
|
||
update_damage
|
||
update_pictures
|
||
update_back_pic
|
||
update_weapons
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトラーデータの更新
|
||
#--------------------------------------------------------------------------
|
||
def update_battler_data
|
||
for battler in $game_party.battle_members + $game_troop.members
|
||
weapon_end(battler) if battler.sv.weapon_end
|
||
next if battler.sv.effect_data == []
|
||
for effect_data in battler.sv.effect_data do set_effects(battler, effect_data) end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ダメージ画像の更新
|
||
#--------------------------------------------------------------------------
|
||
def update_damage
|
||
for i in 0...@damage.size
|
||
next if @damage[i] == nil
|
||
@damage[i].update if @damage[i] != nil
|
||
next if !@damage[i].action_end
|
||
@damage[i].dispose
|
||
@damage[i] = nil
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ピクチャアクションの更新
|
||
#--------------------------------------------------------------------------
|
||
def update_pictures
|
||
for i in 0...@pictures.size
|
||
next if @pictures[i] == nil
|
||
@pictures[i].update if @pictures[i] != nil
|
||
next if !@pictures[i].action_end
|
||
@pictures[i].dispose
|
||
@pictures[i] = nil
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 周期ピクチャの更新
|
||
#--------------------------------------------------------------------------
|
||
def update_back_pic
|
||
set_back_pic if $sv_camera.program_picture != []
|
||
for i in 0...@back_pic.size
|
||
next if @back_pic[i] == nil
|
||
@back_pic[i].update if @back_pic[i] != nil
|
||
next if !@back_pic[i].action_end
|
||
@back_pic[i].dispose
|
||
@back_pic[i] = nil
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 武器アクションの更新
|
||
#--------------------------------------------------------------------------
|
||
def update_weapons
|
||
for i in 0...@weapons.size
|
||
next if @weapons[i] == nil
|
||
@weapons[i].update if @weapons[i] != nil
|
||
next if !@weapons[i].action_end
|
||
@weapons[i].dispose
|
||
@weapons[i] = nil
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ダメージ実行
|
||
#--------------------------------------------------------------------------
|
||
def set_damage_pop(target)
|
||
for i in 0...@damage.size
|
||
next if @damage[i] != nil
|
||
return @damage[i] = Sprite_Damage.new(@viewport, target)
|
||
end
|
||
@damage.push(Sprite_Damage.new(@viewport, target))
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 周期ピクチャ実行
|
||
#--------------------------------------------------------------------------
|
||
def set_back_pic
|
||
for data in $sv_camera.program_picture
|
||
if @back_pic[data[2]] != nil
|
||
@back_pic[data[2]].dispose
|
||
@back_pic[data[2]] = nil
|
||
end
|
||
@back_pic[data[2]] = Sprite_Back_Picture.new(@viewport, data[2])
|
||
@back_pic[data[2]].setup(data)
|
||
end
|
||
$sv_camera.program_picture = []
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● エフェクト開始
|
||
#--------------------------------------------------------------------------
|
||
def set_effects(battler, effect_data)
|
||
case effect_data[0]
|
||
when "pic" ; set_pictures(battler, effect_data)
|
||
when "wp" ; set_weapons(battler, true)
|
||
when "m_a" ; set_weapons(battler, false)
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ピクチャアクション実行
|
||
#--------------------------------------------------------------------------
|
||
def set_pictures(battler, effect_data)
|
||
@pictures[effect_data[1]] = Sprite_Battle_Picture.new if @pictures[effect_data[1]] == nil
|
||
@pictures[effect_data[1]].set(battler)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 武器アクション実行
|
||
#--------------------------------------------------------------------------
|
||
def set_weapons(battler, weapon_flag, test = true)
|
||
for i in 0...@weapons.size
|
||
next if @weapons[i] != nil
|
||
@weapons[i] = Sprite_Weapon.new(@viewport, i, battler)
|
||
battler.sv.weapon_index.push(i) if weapon_flag
|
||
return i
|
||
end
|
||
@weapons.push(Sprite_Weapon.new(@viewport, @weapons.size, battler))
|
||
battler.sv.weapon_index.push(@weapons.size - 1) if weapon_flag
|
||
return @weapons.size - 1
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトラーの武器アクション終了
|
||
#--------------------------------------------------------------------------
|
||
def weapon_end(battler)
|
||
battler.sv.weapon_end = false
|
||
for index in battler.sv.weapon_index
|
||
weapon_index = battler.sv.weapon_index.shift
|
||
@weapons[weapon_index].dispose if @weapons[weapon_index] != nil
|
||
@weapons[weapon_index] = nil
|
||
end
|
||
battler.sv.weapon_index.compact!
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ヒット時の戦闘アニメ実行
|
||
#--------------------------------------------------------------------------
|
||
def set_hit_animation(battler, weapon_index, hit_targets, miss)
|
||
weapon = @weapons[weapon_index]
|
||
for target in hit_targets
|
||
next @weapons[@hit_index].timing_battler_set(target) if @hit_index != nil
|
||
@hit_index = set_weapons(battler, false, false)
|
||
@weapons[@hit_index].set_hit_animation(weapon.hit_position, weapon.hit_anime_id, target)
|
||
end
|
||
@hit_index = nil
|
||
if !weapon.through && !miss
|
||
@weapons[weapon_index].dispose
|
||
@weapons[weapon_index] = nil
|
||
else
|
||
@weapons[weapon_index].through_change
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● サイドビューデータの初期化
|
||
#--------------------------------------------------------------------------
|
||
def reset_sideview
|
||
$sv_camera.reset
|
||
for member in $game_troop.members + $game_party.battle_members do member.sv.reset end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 解放
|
||
#--------------------------------------------------------------------------
|
||
def dispose
|
||
dispose_effects(@weapons)
|
||
dispose_effects(@pictures)
|
||
dispose_effects(@back_pic)
|
||
dispose_effects(@damage)
|
||
reset_sideview
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● エフェクト画像の解放
|
||
#--------------------------------------------------------------------------
|
||
def dispose_effects(effects)
|
||
for i in 0...effects.size
|
||
effects[i].dispose if effects[i] != nil
|
||
effects[i] = nil
|
||
end
|
||
end
|
||
end
|
||
|
||
|
||
#==============================================================================
|
||
# ■ Sprite_Battle_Back
|
||
#------------------------------------------------------------------------------
|
||
# 戦闘背景用のスプライトです。
|
||
#==============================================================================
|
||
class Sprite_Battle_Back < Plane
|
||
#--------------------------------------------------------------------------
|
||
# ● オブジェクト初期化
|
||
#--------------------------------------------------------------------------
|
||
def initialize(viewport = nil, index, battleback_name)
|
||
super(viewport)
|
||
@index = index
|
||
if @index == 1
|
||
data = N03::FLOOR1_DATA[battleback_name]
|
||
data = N03::FLOOR1_DATA["全Battlebacks1"] if data == nil
|
||
elsif @index == 2
|
||
data = N03::FLOOR2_DATA[battleback_name]
|
||
data = N03::FLOOR2_DATA["全Battlebacks2"] if data == nil
|
||
end
|
||
data = data.dup
|
||
@adjust_position = data[0]
|
||
@zoom_x = data[1][0] / 100.0
|
||
@zoom_y = data[1][1] / 100.0
|
||
@shake_on = data[2]
|
||
$game_switches[data[3]] = true if data[3] > 0
|
||
$sv_camera.switches[data[3].abs] = true if data[3] < 0
|
||
reset_scroll
|
||
reset_back_data(battleback_name)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 背景スクロールを初期化
|
||
#--------------------------------------------------------------------------
|
||
def reset_scroll
|
||
@scroll_x = 0
|
||
@scroll_y = 0
|
||
@move_x = 0
|
||
@move_y = 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 背景データを初期化
|
||
#--------------------------------------------------------------------------
|
||
def reset_back_data(battleback_name)
|
||
@back_data = []
|
||
@active_data = ["scroll",0, @move_x, @move_y, false, battleback_name,""]
|
||
start_back_data(@active_data)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 背景画像のセッティング
|
||
#--------------------------------------------------------------------------
|
||
def set_graphics(new_bitmap)
|
||
self.bitmap = new_bitmap
|
||
@base_x = (self.bitmap.width * @zoom_x - Graphics.width) / 2 + @adjust_position[0]
|
||
@base_y = (self.bitmap.height * @zoom_y - Graphics.height) / 2 + @adjust_position[1]
|
||
# 限界座標を取得
|
||
max_top = 0
|
||
max_bottom = self.bitmap.height * @zoom_y - Graphics.height
|
||
max_left = 0
|
||
max_right = self.bitmap.width * @zoom_x - Graphics.width
|
||
exist = true
|
||
exist = false if self.bitmap.height == 32 && self.bitmap.width == 32
|
||
$sv_camera.setting(@index, [max_top, max_bottom, max_left, max_right, @base_x, @base_y,exist])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● フレーム更新
|
||
#--------------------------------------------------------------------------
|
||
def update
|
||
return if !bitmap
|
||
update_back_data
|
||
update_scroll unless @move_x == 0 && @move_y == 0
|
||
update_color
|
||
update_position
|
||
update_back_adjust if @bt_back != nil
|
||
create_back_adjust if @bt_back == nil && !@active_data[10] && @scroll_x == 0 && @scroll_y == 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 背景データを更新
|
||
#--------------------------------------------------------------------------
|
||
def update_back_data
|
||
delete = true if @active_data[1] > 0 && !$game_switches[@active_data[1]]
|
||
delete = true if @active_data[1] < 0 && !$sv_camera.switches[@active_data[1].abs]
|
||
return if !delete
|
||
for i in 0...@back_data.size
|
||
@back_data[i] = nil if @back_data[i][1] > 0 && !$game_switches[@back_data[i][1]]
|
||
@back_data[i] = nil if @back_data[i][1] < 0 && !$sv_camera.switches[@back_data[i][1].abs]
|
||
end
|
||
@back_data.compact!
|
||
next_back_data
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 次の背景データをセット
|
||
#--------------------------------------------------------------------------
|
||
def next_back_data
|
||
@back_data.delete(@active_data[11]) if @active_data[11] != nil
|
||
@back_data.push(@active_data[11]) if @active_data[11] != nil
|
||
@active_data = nil
|
||
data = @back_data.pop
|
||
@back_data = [@active_data] if @back_data.size == 0
|
||
start_back_data(data)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 背景データを実行
|
||
#--------------------------------------------------------------------------
|
||
def start_back_data(data)
|
||
return if back_data_remain(data)
|
||
bt_back_dispose
|
||
pre_active_data = @active_data
|
||
@active_data[8] = [@back_name, @move_x, @move_y, @scroll_x, @scroll_y] if @active_data != nil
|
||
@back_data.push(@active_data) if @active_data != nil
|
||
@active_data = data.dup
|
||
@active_data[5] = @back_name if @active_data[5] == ""
|
||
@active_data[9] = set_back_adjust if @active_data[9] == nil
|
||
back_data_scroll_on if @active_data[8] == nil && @active_data[9][0] == false
|
||
set_remain_back_data if @active_data[8] != nil
|
||
create_back(@active_data[5]) if @active_data[9][0] == false
|
||
create_back_adjust if @active_data[10]
|
||
@active_data[11] = pre_active_data if pre_active_data && @active_data[7] == false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 背景データの保留
|
||
#--------------------------------------------------------------------------
|
||
def back_data_remain(data)
|
||
remain = false
|
||
remain = true if data[6] != "" && @active_data != nil && @active_data[9] != nil && @active_data[9][0] != false
|
||
remain = true if @active_data != nil && @active_data[7] == false
|
||
return remain if !remain
|
||
@remain = true
|
||
@back_data.push(data)
|
||
return remain
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 背景変更補正データをセット
|
||
#--------------------------------------------------------------------------
|
||
def set_back_adjust
|
||
bt_adjust = []
|
||
sign = -1
|
||
if @active_data[6] == ""
|
||
reset_scroll if @active_data[3][0] == 0 && @active_data[3][1] == 0
|
||
bt_adjust = [false,false,0,0]
|
||
return bt_adjust
|
||
elsif @move_x != 0 or @active_data[3][0] != 0
|
||
sign = 1 if @move_x < 0
|
||
bt_adjust[0] = [self.bitmap.width * @zoom_x * sign, 0]
|
||
bt_adjust[1] = [self.bitmap.width * @zoom_x * sign * 2, 0]
|
||
elsif @move_y != 0 or @active_data[3][1] != 0
|
||
sign = 1 if @move_y < 0
|
||
bt_adjust[0] = [0, self.bitmap.height * @zoom_y * sign]
|
||
bt_adjust[1] = [0, self.bitmap.height * @zoom_y * sign * 2]
|
||
else
|
||
reset_scroll if @active_data[3][0] == 0 && @active_data[3][1] == 0
|
||
bt_adjust = [false,false,0,0]
|
||
return bt_adjust
|
||
end
|
||
bt_adjust[2] = [bt_adjust[0][0], bt_adjust[0][1]]
|
||
return bt_adjust
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 背景スクロールデータを実行
|
||
#--------------------------------------------------------------------------
|
||
def back_data_scroll_on
|
||
mirror = $sv_camera.mirror
|
||
mirror = false if !@active_data[4]
|
||
@move_x = @active_data[3][0]
|
||
@move_x *= -1 if mirror
|
||
@move_y = @active_data[3][1]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 保持している背景データを実行
|
||
#--------------------------------------------------------------------------
|
||
def set_remain_back_data
|
||
return back_data_scroll_on if @move_x != 0 or @move_y != 0
|
||
create_back(@active_data[8][0])
|
||
@move_x = @active_data[8][1]
|
||
@move_y = @active_data[8][2]
|
||
@scroll_x = @active_data[8][3]
|
||
@scroll_y = @active_data[8][4]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 背景画像の作成
|
||
#--------------------------------------------------------------------------
|
||
def create_back(back_name)
|
||
return if back_name == @back_name or back_name == ""
|
||
self.bitmap = Cache.battleback1(back_name) if @index == 1
|
||
self.bitmap = Cache.battleback2(back_name) if @index == 2
|
||
@back_name = back_name
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 背景変更補正画像の作成
|
||
#--------------------------------------------------------------------------
|
||
def create_back_adjust
|
||
return if @active_data[9][0] == false
|
||
@active_data[10] = true
|
||
mirror = $sv_camera.mirror
|
||
mirror = false if !@active_data[4]
|
||
@bt_back = []
|
||
@bt_back[0] = Sprite.new(viewport)
|
||
@bt_back[0].bitmap = Cache.battleback1(@active_data[6]) if @index == 1
|
||
@bt_back[0].bitmap = Cache.battleback2(@active_data[6]) if @index == 2
|
||
@bt_back[0].mirror = mirror
|
||
@bt_back[1] = Sprite.new(viewport)
|
||
@bt_back[1].bitmap = Cache.battleback1(@active_data[5]) if @index == 1
|
||
@bt_back[1].bitmap = Cache.battleback2(@active_data[5]) if @index == 2
|
||
@bt_back[1].mirror = mirror
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 背景スクロールの更新
|
||
#--------------------------------------------------------------------------
|
||
def update_scroll
|
||
@scroll_x += @move_x
|
||
@scroll_y += @move_y
|
||
@scroll_x = 0 if @scroll_x / 100 >= self.bitmap.width * @zoom_x or @scroll_x / 100 <= -self.bitmap.width * @zoom_x
|
||
@scroll_y = 0 if @scroll_y / 100 >= self.bitmap.height * @zoom_y or @scroll_y / 100 <= -self.bitmap.height * @zoom_y
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 色調変更の更新
|
||
#--------------------------------------------------------------------------
|
||
def update_color
|
||
color_set if $sv_camera.color_set[@index] != nil
|
||
return if @color_data == nil
|
||
@color_data[4] -= 1
|
||
if @color_data[4] == 0 && @color_data[5] != 0
|
||
@color_data[4] = @color_data[5]
|
||
@color_data[5] = 0
|
||
@color_data[6] = [0,0,0,0]
|
||
elsif @color_data[4] == 0
|
||
@remain_color_data = @color_data
|
||
return @color_data = nil
|
||
end
|
||
for i in 0..3
|
||
@color_data[i] = (@color_data[i] * (@color_data[4] - 1) + @color_data[6][i]) / @color_data[4]
|
||
end
|
||
self.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 座標の更新
|
||
#--------------------------------------------------------------------------
|
||
def update_position
|
||
self.ox = $sv_camera.x + @base_x - @scroll_x / 100
|
||
self.oy = $sv_camera.y + @base_y - @scroll_y / 100
|
||
self.ox -= $sv_camera.sx / 100 if @shake_on
|
||
self.oy -= $sv_camera.sy / 100 if @shake_on
|
||
self.zoom_x = @zoom_x * $sv_camera.zoom
|
||
self.zoom_y = @zoom_y * $sv_camera.zoom
|
||
self.ox *= $sv_camera.zoom
|
||
self.oy *= $sv_camera.zoom
|
||
self.z = @index * 10
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 背景変更補正画像を更新
|
||
#--------------------------------------------------------------------------
|
||
def update_back_adjust
|
||
@active_data[9][0][0] = 0 if @scroll_x == 0
|
||
@active_data[9][0][1] = 0 if @scroll_y == 0
|
||
@active_data[9][1][0] -= @active_data[9][2][0] if @scroll_x == 0
|
||
@active_data[9][1][1] -= @active_data[9][2][1] if @scroll_y == 0
|
||
for i in 0...@bt_back.size
|
||
@bt_back[i].x = -self.ox + @active_data[9][i][0] * $sv_camera.zoom
|
||
@bt_back[i].y = -self.oy + @active_data[9][i][1] * $sv_camera.zoom
|
||
@bt_back[i].zoom_x = self.zoom_x
|
||
@bt_back[i].zoom_y = self.zoom_y
|
||
@bt_back[i].z = self.z + 1
|
||
@bt_back[i].color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
|
||
end
|
||
back_data_scroll_on if @active_data[9][0][0] == 0 && @active_data[9][0][1] == 0
|
||
return unless @active_data[9][1][0] == 0 && @active_data[9][1][1] == 0
|
||
bt_back_dispose
|
||
create_back(@active_data[5])
|
||
@active_data[9][0] = false
|
||
next_back_data if @remain && @back_data.size != 1
|
||
@remain = false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 色調変更
|
||
#--------------------------------------------------------------------------
|
||
def color_set
|
||
set = $sv_camera.color_set[@index]
|
||
$sv_camera.color_set[@index] = nil
|
||
set[4] = 1 if set[4] == 0
|
||
@remain_color_data = [0,0,0,0] if @remain_color_data == nil
|
||
@color_data = @remain_color_data
|
||
@color_data[4] = set[4]
|
||
@color_data[5] = set[5]
|
||
@color_data[6] = set
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 背景変更補正画像の解放
|
||
#--------------------------------------------------------------------------
|
||
def bt_back_dispose
|
||
for i in 0...@bt_back.size do @bt_back[i].dispose end if @bt_back != nil
|
||
@bt_back = nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 解放
|
||
#--------------------------------------------------------------------------
|
||
def dispose
|
||
bitmap.dispose if bitmap
|
||
bt_back_dispose
|
||
super
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Battle_Camera
|
||
#------------------------------------------------------------------------------
|
||
# 戦闘カメラやバトルプログラムを扱うクラスです。
|
||
#==============================================================================
|
||
class Battle_Camera
|
||
#--------------------------------------------------------------------------
|
||
# ● 公開インスタンス変数
|
||
#--------------------------------------------------------------------------
|
||
attr_reader :sx # シェイクX座標
|
||
attr_reader :sy # シェイクY座標
|
||
attr_reader :max_top # 上限界座標
|
||
attr_reader :max_bottom # 下限界座標
|
||
attr_reader :max_left # 左限界座標
|
||
attr_reader :max_right # 右限界座標
|
||
attr_accessor :switches # サイドビュー専用スイッチ
|
||
attr_accessor :color_set # 色調変更データ
|
||
attr_accessor :wait # 戦闘シーンの強制ウエイト
|
||
attr_accessor :win_wait # 戦闘勝利前のウエイト
|
||
attr_accessor :mirror # 画面反転フラグ
|
||
attr_accessor :program_scroll # バトルプログラム 背景の自動スクロール
|
||
attr_accessor :program_picture # バトルプログラム 周期ピクチャ
|
||
attr_accessor :event # コモンイベント呼び出し
|
||
#--------------------------------------------------------------------------
|
||
# ● オブジェクト初期化
|
||
#--------------------------------------------------------------------------
|
||
def initialize
|
||
@switches = []
|
||
@max_data = []
|
||
@color_set = []
|
||
@wait = 0
|
||
@win_wait = false
|
||
@mirror = false
|
||
@event = false
|
||
setup
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● カメラX座標
|
||
#--------------------------------------------------------------------------
|
||
def x
|
||
return @x / 100
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● カメラY座標
|
||
#--------------------------------------------------------------------------
|
||
def y
|
||
return @y / 100
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ズーム率
|
||
#--------------------------------------------------------------------------
|
||
def zoom
|
||
return @zoom * 0.001
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ズーム率による座標変換
|
||
#--------------------------------------------------------------------------
|
||
def convert
|
||
return @zoom
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● カメラセットアップ
|
||
#--------------------------------------------------------------------------
|
||
def setup
|
||
@x = 0
|
||
@y = 0
|
||
@sx = 0
|
||
@sy = 0
|
||
@zoom = 1000
|
||
@time = 0
|
||
@shake_time = 0
|
||
program_setup
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● カメラ初期化
|
||
#--------------------------------------------------------------------------
|
||
def reset
|
||
@switches = []
|
||
@max_data = []
|
||
@color_set = []
|
||
@wait = 0
|
||
@win_wait = false
|
||
@mirror = false
|
||
program_setup(false)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトルプログラムのセットアップ
|
||
#--------------------------------------------------------------------------
|
||
def program_setup(check = true)
|
||
@played_program = []
|
||
@program_switch = []
|
||
@program_sound = []
|
||
@program_scroll = []
|
||
@program_se = []
|
||
@program_shake = []
|
||
@program_color = []
|
||
@program_picture = []
|
||
@program_base = N03::BATTLE_PROGRAM.values.dup
|
||
program_check if check
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトルプログラムのチェック
|
||
#--------------------------------------------------------------------------
|
||
def program_check
|
||
for data in @program_base
|
||
if program_start?(data) && !@played_program.include?(data)
|
||
@played_program.push(data.dup)
|
||
@program_scroll.push(data.dup) if data[0] == "scroll"
|
||
@program_picture.push(data.dup) if data[0] == "kpic"
|
||
start_sound(data.dup) if data[0] == "sound"
|
||
start_program_switch(data.dup) if data[0] == "switch"
|
||
start_program_se(data.dup) if data[0] == "keep_se"
|
||
start_program_shake(data.dup) if data[0] == "keep_sk"
|
||
start_program_color(data.dup) if data[0] == "keep_c"
|
||
else
|
||
@played_program.delete(data) if !program_start?(data)
|
||
@program_scroll.delete(data) if data[0] == "scroll"
|
||
@program_picture.delete(data) if data[0] == "kpic"
|
||
@program_switch.delete(data) if data[0] == "switch"
|
||
@program_sound.delete(data) if data[0] == "sound"
|
||
@program_se.delete(data) if data[0] == "keep_se"
|
||
@program_shake.delete(data) if data[0] == "keep_sk"
|
||
@program_color.delete(data) if data[0] == "keep_c"
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトルプログラムの開始
|
||
#--------------------------------------------------------------------------
|
||
def program_start?(data)
|
||
start = false
|
||
start = true if $game_switches[data[1].abs] && data[1] > 0
|
||
start = true if @switches[data[1].abs] && data[1] < 0
|
||
return start
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトルプログラム スイッチ操作の開始
|
||
#--------------------------------------------------------------------------
|
||
def start_program_switch(data)
|
||
data[4] = data[4] + rand(data[5] + 1)
|
||
data[4] = 1 if data[4] <= 0
|
||
@program_switch.push(data)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スイッチ操作の更新
|
||
#--------------------------------------------------------------------------
|
||
def update_program_switch
|
||
for data in @program_switch
|
||
data[4] -= 1
|
||
next @program_switch.delete(data) if data[1] > 0 && !$game_switches[data[1]]
|
||
next @program_switch.delete(data) if data[1] < 0 && !@switches[data[1].abs]
|
||
next if data[4] != 0
|
||
for id in data[2]
|
||
$game_switches[id] = true if id > 0
|
||
@switches[id.abs] = true if id < 0
|
||
end
|
||
for id in data[3]
|
||
$game_switches[id] = false if id > 0
|
||
@switches[id.abs] = false if id < 0
|
||
end
|
||
@program_switch.delete(data)
|
||
program_check
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトルプログラム BGM/BGSの開始
|
||
#--------------------------------------------------------------------------
|
||
def start_sound(data)
|
||
@program_sound.push(data)
|
||
name = data[5]
|
||
case data[2]
|
||
when "se"
|
||
Audio.se_play("Audio/SE/" + name, data[4], data[3])
|
||
when "bgm"
|
||
name = RPG::BGM.last.name if data[5] == ""
|
||
Audio.bgm_play("Audio/BGM/" + name, data[4], data[3])
|
||
when "bgs"
|
||
name = RPG::BGS.last.name if data[5] == ""
|
||
Audio.bgs_play("Audio/BGS/" + name, data[4], data[3])
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトルプログラム 周期SEの開始
|
||
#--------------------------------------------------------------------------
|
||
def start_program_se(data)
|
||
data[3] = [data[2], data[3]]
|
||
data[2] = data[3][0] + rand(data[3][1] + 1)
|
||
@program_se.push(data)
|
||
Audio.se_play("Audio/SE/" + data[7], data[5], data[4]) if data[6]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 周期SEの更新
|
||
#--------------------------------------------------------------------------
|
||
def update_program_se
|
||
for data in @program_se
|
||
data[2] -= 1
|
||
next @program_se.delete(data) if data[1] > 0 && !$game_switches[data[1]]
|
||
next @program_se.delete(data) if data[1] < 0 && !@switches[data[1].abs]
|
||
next if data[2] != 0
|
||
Audio.se_play("Audio/SE/" + data[7], data[5], data[4])
|
||
data[2] = data[3][0] + rand(data[3][1] + 1)
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトルプログラム 周期シェイクの開始
|
||
#--------------------------------------------------------------------------
|
||
def start_program_shake(data)
|
||
data[3] = [data[2], data[3]]
|
||
data[2] = data[3][0] + rand(data[3][1] + 1)
|
||
@program_shake.push(data)
|
||
shake(data[4], data[5], data[6]) if data[7]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 周期シェイクの更新
|
||
#--------------------------------------------------------------------------
|
||
def update_program_shake
|
||
for data in @program_shake
|
||
data[2] -= 1
|
||
next @program_shake.delete(data) if data[1] > 0 && !$game_switches[data[1]]
|
||
next @program_shake.delete(data) if data[1] < 0 && !@switches[data[1].abs]
|
||
next if data[2] != 0
|
||
shake(data[4], data[5], data[6])
|
||
data[2] = data[3][0] + rand(data[3][1] + 1)
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトルプログラム 周期色調変更の開始
|
||
#--------------------------------------------------------------------------
|
||
def start_program_color(data)
|
||
data[3] = [data[2], data[3]]
|
||
data[2] = data[3][0] + rand(data[3][1] + 1)
|
||
data[7] = true if data[4] == 0 or data[4] == 4
|
||
case data[4]
|
||
when 1 ;data[4] = $game_troop.members
|
||
when 2 ;data[4] = $game_party.battle_members
|
||
when 3,4 ;data[4] = $game_troop.members + $game_party.battle_members
|
||
else ;data[4] = []
|
||
end
|
||
@program_color.push(data)
|
||
return if !data[6]
|
||
for target in data[4] do target.sv.color_set = data[5] end if data[4] != []
|
||
@color_set[1] = data[5] if data[7]
|
||
@color_set[2] = data[5] if data[7]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 周期色調変更の更新
|
||
#--------------------------------------------------------------------------
|
||
def update_program_color
|
||
for data in @program_color
|
||
data[2] -= 1
|
||
next @program_color.delete(data) if data[1] > 0 && !$game_switches[data[1]]
|
||
next @program_color.delete(data) if data[1] < 0 && !@switches[data[1].abs]
|
||
next if data[2] != 0
|
||
for target in data[4] do target.sv.color_set = data[5] end if data[4] != []
|
||
@color_set[1] = data[5] if data[7]
|
||
@color_set[2] = data[5] if data[7]
|
||
data[2] = data[3][0] + rand(data[3][1] + 1)
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● トランジション実行
|
||
#--------------------------------------------------------------------------
|
||
def perform_transition(data)
|
||
Graphics.transition(data[2], "Graphics/Pictures/" + data[3], data[1])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 背景からカメラの限界値を取得 data = [max_top, max_bottom, max_left, max_right]
|
||
#--------------------------------------------------------------------------
|
||
def setting(index, data)
|
||
@max_data[index - 1] = data
|
||
return if index != 2
|
||
setup
|
||
# カメラの中心座標
|
||
@center_x = (Graphics.width / 2 + N03::CAMERA_POSITION[0]) * 100
|
||
@center_y = (Graphics.height / 2 + N03::CAMERA_POSITION[1]) * 100
|
||
# 上下左右の移動限界距離
|
||
@max_top = [@max_data[0][5], @max_data[1][5]].min * -1
|
||
@max_bottom = [@max_data[0][1], @max_data[1][1]].min + @max_top
|
||
@max_left = [@max_data[0][4], @max_data[1][4]].min * -1
|
||
@max_right = [@max_data[0][3], @max_data[1][3]].min + @max_left
|
||
exist_data = @max_data[0] if !@max_data[1][6]
|
||
exist_data = @max_data[1] if !@max_data[0][6]
|
||
@max_top = exist_data[5] * -1 if exist_data != nil
|
||
@max_bottom = exist_data[1] + @max_top if exist_data != nil
|
||
@max_left = exist_data[4] * -1 if exist_data != nil
|
||
@max_right = exist_data[3] + @max_left if exist_data != nil
|
||
@max_top = @max_bottom = @max_left = @max_right = 0 if !@max_data[1][6] && !@max_data[0][6]
|
||
@max_width = @max_right - @max_left + Graphics.width
|
||
@max_height = @max_bottom - @max_top + Graphics.height
|
||
# ズームアウト限界値
|
||
max_zoom_x = 100 * Graphics.width / @max_width
|
||
max_zoom_y = 100 * Graphics.height / @max_height
|
||
@max_zoom_out = [max_zoom_x, max_zoom_y].max
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● カメラ移動
|
||
#--------------------------------------------------------------------------
|
||
def move(target_x, target_y, zoom, time, screen = true)
|
||
# 戦闘背景以上のサイズまでズームアウトしないよう調整
|
||
@target_zoom = [zoom * 0.01, @max_zoom_out * 0.01].max
|
||
target_x *= -1 if screen && @mirror
|
||
# ズーム分の中心座標補正
|
||
if screen && @target_zoom != 1
|
||
target_x = target_x + @center_x
|
||
target_y = target_y + @center_y
|
||
end
|
||
adjust_x = @center_x * (@target_zoom - 1) / (@target_zoom ** 2 - @target_zoom)
|
||
adjust_y = @center_y * (@target_zoom - 1) / (@target_zoom ** 2 - @target_zoom)
|
||
adjust_x = 0 if adjust_x.nan?
|
||
adjust_y = 0 if adjust_y.nan?
|
||
adjust_x = @center_x if !screen && adjust_x == 0
|
||
adjust_y = @center_y if !screen && adjust_y == 0
|
||
@target_x = target_x - adjust_x.to_i
|
||
@target_y = target_y - adjust_y.to_i
|
||
@target_zoom = (@target_zoom * 1000).to_i
|
||
@zoom = @zoom.to_i
|
||
limit_test
|
||
# 時間0の場合は即実行
|
||
return @time = time.abs if time != 0
|
||
@time = 1
|
||
update
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 限界座標の試算
|
||
#--------------------------------------------------------------------------
|
||
def limit_test
|
||
new_width = @max_width * @target_zoom / 1000
|
||
new_height = @max_height * @target_zoom / 1000
|
||
new_max_right = @max_right - (@max_width - new_width)
|
||
new_max_bottom = @max_bottom - (@max_height - new_height)
|
||
# 画面の移動先が限界の場合、限界座標をセット
|
||
if @target_x < @max_left * 100
|
||
@target_x = @max_left * 100
|
||
end
|
||
if @target_x > new_max_right * 100
|
||
@target_x = new_max_right * 100
|
||
end
|
||
if @target_y < @max_top * 100
|
||
@target_y = @max_top * 100
|
||
end
|
||
if @target_y > new_max_bottom * 100
|
||
@target_y = new_max_bottom * 100
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 画面のシェイク
|
||
#--------------------------------------------------------------------------
|
||
def shake(power, speed, time)
|
||
@shake_x = power[0] * 100
|
||
@shake_y = power[1] * 100
|
||
@power_time_base = @power_time = speed
|
||
@shake_time = time
|
||
update_shake
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● シェイクの更新
|
||
#--------------------------------------------------------------------------
|
||
def update_shake
|
||
@sx = (@sx * (@power_time - 1) + @shake_x) / @power_time
|
||
@sy = (@sy * (@power_time - 1) + @shake_y) / @power_time
|
||
@power_time -= 1
|
||
@shake_time -= 1
|
||
return @sx = @sy = 0 if @shake_time == 0
|
||
return if @power_time != 0
|
||
@power_time = @power_time_base
|
||
@shake_x = @shake_x * -4 / 5
|
||
@shake_y = @shake_y * -4 / 5
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● フレーム更新
|
||
#--------------------------------------------------------------------------
|
||
def update
|
||
update_shake if @shake_time != 0
|
||
update_program
|
||
return if @time == 0
|
||
@x = (@x * (@time - 1) + @target_x) / @time
|
||
@y = (@y * (@time - 1) + @target_y) / @time
|
||
@zoom = (@zoom * (@time - 1) + @target_zoom) / @time
|
||
@time -= 1
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● フレーム更新
|
||
#--------------------------------------------------------------------------
|
||
def update_program
|
||
update_program_switch if @program_switch != []
|
||
update_program_se if @program_se != []
|
||
update_program_shake if @program_shake != []
|
||
update_program_color if @program_color != []
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Scene_Battle
|
||
#------------------------------------------------------------------------------
|
||
# バトル画面の処理を行うクラスです。
|
||
#==============================================================================
|
||
class Scene_Battle < Scene_Base
|
||
#--------------------------------------------------------------------------
|
||
# ● フレーム更新（基本）
|
||
#--------------------------------------------------------------------------
|
||
alias update_basic_scene_battle_n03 update_basic
|
||
def update_basic
|
||
update_basic_scene_battle_n03
|
||
$sv_camera.update
|
||
$sv_camera.wait = N03::TURN_END_WAIT + 1 if $sv_camera.win_wait
|
||
camera_wait
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● カメラウェイト
|
||
#--------------------------------------------------------------------------
|
||
def camera_wait
|
||
process_event if $sv_camera.event
|
||
$sv_camera.event = false if $sv_camera.event
|
||
while $sv_camera.wait != 0
|
||
Graphics.update
|
||
Input.update
|
||
update_all_windows
|
||
$game_timer.update
|
||
$game_troop.update
|
||
$sv_camera.update
|
||
@spriteset.update
|
||
update_info_viewport
|
||
update_message_open
|
||
$sv_camera.wait -= 1 if $sv_camera.wait > 0
|
||
$sv_camera.wait = 1 if $sv_camera.wait == 0 && @spriteset.effect?
|
||
BattleManager.victory if $sv_camera.win_wait && $sv_camera.wait == 0
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● カメラウェイトのセット
|
||
#--------------------------------------------------------------------------
|
||
def set_camera_wait(time)
|
||
$sv_camera.wait = time
|
||
camera_wait
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● エフェクト実行が終わるまでウェイト ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def wait_for_effect
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ターン開始
|
||
#--------------------------------------------------------------------------
|
||
alias turn_start_scene_battle_n03 turn_start
|
||
def turn_start
|
||
turn_start_scene_battle_n03
|
||
N03.camera(nil, N03::BATTLE_CAMERA["ターン開始後"].dup)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ターン終了
|
||
#--------------------------------------------------------------------------
|
||
alias turn_end_scene_battle_n03 turn_end
|
||
def turn_end
|
||
turn_end_scene_battle_n03
|
||
for member in $game_troop.members + $game_party.members
|
||
N03.set_damage(member, member.sv.result_damage[0],member.sv.result_damage[1])
|
||
member.sv.result_damage = [0,0]
|
||
@spriteset.set_damage_pop(member) if member.result.hp_damage != 0 or member.result.mp_damage != 0
|
||
end
|
||
set_camera_wait(N03::TURN_END_WAIT)
|
||
N03.camera(nil, N03::BATTLE_CAMERA["ターン開始前"].dup) if $game_party.inputable?
|
||
@log_window.clear
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキル／アイテムの使用 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def use_item
|
||
item = @subject.current_action.item
|
||
display_item(item)
|
||
@subject.use_item(item)
|
||
refresh_status
|
||
@targets = @subject.current_action.make_targets.compact
|
||
@targets = [@subject] if @targets.size == 0
|
||
set_substitute(item)
|
||
for time in item.repeats.times do play_sideview(@targets, item) end
|
||
end_reaction(item)
|
||
display_end_item
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキル／アイテム名の表示
|
||
#--------------------------------------------------------------------------
|
||
def display_item(item)
|
||
return @log_window.display_use_item(@subject, item) if N03::BATTLE_LOG
|
||
@log_window.off
|
||
@skill_name_window = Window_Skill_name.new(item.name) unless N03::NO_DISPLAY_SKILL_ID.include?(item.id) && item.is_a?(RPG::Skill)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スキル／アイテム名の表示終了
|
||
#--------------------------------------------------------------------------
|
||
def display_end_item
|
||
@skill_name_window.dispose if @skill_name_window != nil
|
||
@skill_name_window = nil
|
||
set_camera_wait(N03::ACTION_END_WAIT) if @subject.sv.derivation_skill_id == 0
|
||
@log_window.clear if N03::BATTLE_LOG
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 反撃／魔法反射／身代わり処理
|
||
#--------------------------------------------------------------------------
|
||
def end_reaction(item)
|
||
end_substitute if @substitute != nil
|
||
set_reflection(item) if @reflection_data != nil
|
||
set_counter_attack if @counter_attacker != nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 反撃の発動 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def invoke_counter_attack(target, item)
|
||
return if @subject.sv.counter_id != 0
|
||
@counter_attacker = [] if @counter_attacker == nil
|
||
return apply_item_effects(apply_substitute(target, item), item) if !target.movable?
|
||
@log_window.add_text(sprintf(Vocab::CounterAttack, target.name)) if N03::BATTLE_LOG
|
||
Audio.se_play("Audio/SE/Sword2", $game_system.m_v[3], 80)#紅茶走
|
||
target.sv.counter_id = target.sv.counter_skill_id
|
||
@counter_attacker.push(target)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 魔法反射の発動 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def invoke_magic_reflection(target, item)
|
||
return if @subject.sv.reflection_id != 0
|
||
@log_window.add_text(sprintf(Vocab::MagicReflection, target.name)) if N03::BATTLE_LOG
|
||
target.sv.reflection_id = target.sv.reflection_anime_id
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 身代わりの適用 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def apply_substitute(target, item)
|
||
return target if @substitute == nil
|
||
return target if !check_substitute(target, item)
|
||
return @substitute
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 身代わりセット
|
||
#--------------------------------------------------------------------------
|
||
def set_substitute(item)
|
||
@substitute = N03.get_enemy_unit(@subject).substitute_battler
|
||
return if @substitute == nil
|
||
s_targets = []
|
||
for i in 0...@targets.size
|
||
next if @targets[i] == @substitute
|
||
next if !check_substitute(@targets[i], item)
|
||
@log_window.add_text(sprintf(Vocab::Substitute, @substitute.name, @targets[i].name))
|
||
@targets[i].sv.start_action(@targets[i].sv.substitute_receiver_start_action)
|
||
s_targets.push(@targets[i])
|
||
@targets[i] = @substitute
|
||
end
|
||
return @substitute = nil if s_targets == []
|
||
@substitute.sv.set_target(s_targets)
|
||
@substitute.sv.start_action(@substitute.sv.substitute_start_action)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 身代わり終了
|
||
#--------------------------------------------------------------------------
|
||
def end_substitute
|
||
for member in @substitute.sv.target_battler
|
||
member.sv.start_action(member.sv.substitute_receiver_end_action)
|
||
end
|
||
@substitute.sv.start_action(@substitute.sv.substitute_end_action)
|
||
@substitute = nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 反撃
|
||
#--------------------------------------------------------------------------
|
||
def set_counter_attack
|
||
pre_subject = @subject
|
||
for attacker in @counter_attacker
|
||
@subject = attacker
|
||
item = $data_skills[attacker.sv.counter_skill_id]
|
||
play_sideview([pre_subject], item)
|
||
end
|
||
# 同一カウンター者を考慮してカウンターIDの初期化はアクション後に実行
|
||
for attacker in @counter_attacker do attacker.sv.counter_id = 0 end
|
||
@subject = pre_subject
|
||
@counter_attacker = nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 魔法反射
|
||
#--------------------------------------------------------------------------
|
||
def set_reflection(item)
|
||
@log_window.back_to(1)
|
||
for data in @reflection_data
|
||
@subject.sv.damage_action(@subject, item)
|
||
N03.set_damage_anime_data([@subject], @subject, data)
|
||
apply_item_effects(@subject, item)
|
||
@spriteset.set_damage_pop(@subject)
|
||
end
|
||
set_camera_wait(N03.get_anime_time(@reflection_data[0][0]))
|
||
@reflection_data = nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● サイドビューアクション実行
|
||
#--------------------------------------------------------------------------
|
||
def play_sideview(targets, item)
|
||
@subject.sv.set_target(targets)
|
||
return if @subject.sv.attack_action(item) == nil
|
||
return if !@subject.movable?
|
||
return if item.scope != 9 && item.scope != 10 && !N03.targets_alive?(targets)
|
||
@subject.sv.start_action(@subject.sv.attack_action(item))
|
||
@subject.sv.unshift_action(@subject.sv.flash_action) if @subject.flash_flg
|
||
@subject.sv.active = true
|
||
@subject.sv.command_action = false
|
||
loop do
|
||
update_basic
|
||
data = @subject.sv.play_data
|
||
@targets = N03.s_targets(@subject) if data[0] == "second_targets_set"
|
||
N03.targets_set(@subject) if data[0] == "targets_set"
|
||
@immortal = N03.immortaling if data[0] == "no_collapse" && !N03.dead_attack?(@subject, item)
|
||
@immortal = N03.unimmortaling if data[0] == "collapse"
|
||
next set_move_anime(item) if @subject.sv.m_a_data != []
|
||
set_damage(item) if @subject.sv.set_damage
|
||
break N03.derived_skill(@subject) if @subject.sv.derivation_skill_id != 0
|
||
break if @subject.sv.action_end or @subject.hidden?
|
||
end
|
||
@immortal = N03.unimmortaling if @immortal
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ダメージの実行
|
||
#--------------------------------------------------------------------------
|
||
def set_damage(item)
|
||
targets = @targets
|
||
targets = [@subject.sv.individual_targets[0]] if @subject.sv.individual_targets.size != 0
|
||
for target in targets do damage_anime(targets.dup, target, item) end
|
||
@subject.sv.set_damage = false
|
||
@subject.sv.damage_anime_data = []
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ダメージ戦闘アニメ処理
|
||
#--------------------------------------------------------------------------
|
||
def damage_anime(targets, target, item)
|
||
@log_window.back_to(1) if @log_window.line_number == 5
|
||
return if item.scope != 9 && item.scope != 10 && target.dead?
|
||
@miss = false
|
||
invoke_item(target,item)
|
||
if target.result.missed
|
||
target.sv.miss_action(@subject, item)
|
||
return @miss = true
|
||
elsif target.result.evaded or target.sv.counter_id != 0
|
||
target.sv.evasion_action(@subject, item)
|
||
return @miss = true
|
||
elsif target.sv.reflection_id != 0
|
||
N03.set_damage_anime_data(targets, target, [target.sv.reflection_id, false, false, true])
|
||
target.sv.reflection_id = 0
|
||
@reflection_data = [] if @reflection_data == nil
|
||
return @reflection_data.push([N03.get_attack_anime_id(-3, @subject), false, false, true])
|
||
end
|
||
target.sv.damage_action(@subject, item)
|
||
N03.set_damage(@subject, -target.result.hp_drain, -target.result.mp_drain) if target != @subject
|
||
@spriteset.set_damage_pop(target)
|
||
@spriteset.set_damage_pop(@subject) if target != @subject && @subject.result.hp_damage != 0 or @subject.result.mp_damage != 0
|
||
N03.set_damage_anime_data(targets, target, @subject.sv.damage_anime_data) if @subject.sv.damage_anime_data != []
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 飛ばしアニメ処理
|
||
#--------------------------------------------------------------------------
|
||
def set_move_anime(item)
|
||
for data in @subject.sv.m_a_data
|
||
@subject.sv.damage_anime_data = data[4]
|
||
hit_targets = []
|
||
for target in data[1]
|
||
damage_anime(data[1], target, item) if data[0]
|
||
hit_targets.push(target) if !@miss
|
||
end
|
||
@miss = false if !data[3]
|
||
@spriteset.set_hit_animation(@subject, data[2], hit_targets, @miss)
|
||
end
|
||
@subject.sv.set_damage = false
|
||
@subject.sv.m_a_data = []
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ DataManager
|
||
#------------------------------------------------------------------------------
|
||
# データベースとゲームオブジェクトを管理するモジュールです。
|
||
#==============================================================================
|
||
module DataManager
|
||
#--------------------------------------------------------------------------
|
||
# ● 各種ゲームオブジェクトの作成 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def self.create_game_objects
|
||
$game_temp = Game_Temp.new
|
||
$game_system = Game_System.new
|
||
$game_timer = Game_Timer.new
|
||
$game_message = Game_Message.new
|
||
$game_switches = Game_Switches.new
|
||
$game_variables = Game_Variables.new
|
||
$game_self_switches = Game_SelfSwitches.new
|
||
$game_actors = Game_Actors.new
|
||
$game_party = Game_Party.new
|
||
$game_troop = Game_Troop.new
|
||
$game_map = Game_Map.new
|
||
$game_player = Game_Player.new
|
||
$sv_camera = Battle_Camera.new
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ BattleManager
|
||
#------------------------------------------------------------------------------
|
||
# 戦闘の進行を管理するモジュールです。
|
||
#==============================================================================
|
||
module BattleManager
|
||
#--------------------------------------------------------------------------
|
||
# ● エンカウント時の処理 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def self.on_encounter
|
||
@preemptive = (rand < rate_preemptive)
|
||
@surprise = (rand < rate_surprise && !@preemptive)
|
||
$sv_camera.mirror = @surprise if N03::BACK_ATTACK
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 勝利の処理 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def self.process_victory
|
||
$sv_camera.win_wait = true
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 勝利
|
||
#--------------------------------------------------------------------------
|
||
def self.victory
|
||
$sv_camera.win_wait = false
|
||
N03.camera(nil, N03::BATTLE_CAMERA["戦闘終了時"].dup)
|
||
for member in $game_party.members do member.sv.start_action(member.sv.win) if member.movable? end
|
||
play_battle_end_me
|
||
replay_bgm_and_bgs
|
||
$game_message.add(sprintf(Vocab::Victory, $game_party.name))
|
||
display_exp
|
||
gain_gold
|
||
gain_drop_items
|
||
gain_exp
|
||
SceneManager.return
|
||
battle_end(0)
|
||
return true
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 逃走の処理 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def self.process_escape
|
||
$game_message.add(sprintf(Vocab::EscapeStart, $game_party.name))
|
||
success = @preemptive ? true : (rand < @escape_ratio)
|
||
Sound.play_escape
|
||
if success
|
||
process_abort
|
||
for member in $game_party.members do member.sv.start_action(member.sv.escape) if member.movable? end
|
||
else
|
||
@escape_ratio += 0.1
|
||
$game_message.add('\.' + Vocab::EscapeFailure)
|
||
$game_party.clear_actions
|
||
for member in $game_party.members do member.sv.start_action(member.sv.escape_ng) if member.movable? end
|
||
end
|
||
wait_for_message
|
||
return success
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 次のコマンド入力へ ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def self.next_command
|
||
begin
|
||
if !actor || !actor.next_command
|
||
$game_party.battle_members[@actor_index].sv.command_action = true
|
||
@actor_index += 1
|
||
if @actor_index >= $game_party.members.size
|
||
for member in $game_party.battle_members.reverse
|
||
break member.sv.start_action(member.sv.command_a) if member.inputable?
|
||
end
|
||
return false
|
||
end
|
||
end
|
||
end until actor.inputable?
|
||
actor.sv.start_action(actor.sv.command_b) if actor != nil && actor.inputable?
|
||
if pre_actor
|
||
pre_actor.sv.start_action(pre_actor.sv.command_a) if pre_actor != nil && pre_actor.inputable?
|
||
end
|
||
return true
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 前のコマンド入力へ ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def self.prior_command
|
||
begin
|
||
if !actor || !actor.prior_command
|
||
$game_party.battle_members[@actor_index].sv.command_action = false
|
||
@actor_index -= 1
|
||
if @actor_index < 0
|
||
for member in $game_party.battle_members
|
||
break member.sv.start_action(member.sv.command_a) if member.inputable?
|
||
end
|
||
return false
|
||
end
|
||
end
|
||
end until actor.inputable?
|
||
actor.make_actions if actor.inputable?
|
||
actor.sv.start_action(actor.sv.command_b) if actor.inputable?
|
||
after_actor.sv.start_action(after_actor.sv.command_a) if after_actor != nil && after_actor.inputable?
|
||
return true
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● コマンド入力前のアクターを取得
|
||
#--------------------------------------------------------------------------
|
||
def self.pre_actor
|
||
return if @actor_index == 0
|
||
$game_party.members[@actor_index - 1]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● コマンド入力後のアクターを取得
|
||
#--------------------------------------------------------------------------
|
||
def self.after_actor
|
||
$game_party.members[@actor_index + 1]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 戦闘行動者を前に追加
|
||
#--------------------------------------------------------------------------
|
||
def self.unshift_action_battlers(battler)
|
||
@action_battlers.unshift(battler)
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Game_Battler
|
||
#------------------------------------------------------------------------------
|
||
# スプライトや行動に関するメソッドを追加したバトラーのクラスです。
|
||
#==============================================================================
|
||
class Game_Battler < Game_BattlerBase
|
||
#--------------------------------------------------------------------------
|
||
# ● 公開インスタンス変数
|
||
#--------------------------------------------------------------------------
|
||
attr_reader :sv # サイドビューデータ
|
||
attr_accessor :flash_flg # 閃きフラグ
|
||
#--------------------------------------------------------------------------
|
||
# ● オブジェクト初期化
|
||
#--------------------------------------------------------------------------
|
||
alias initialize_game_battler_n03 initialize
|
||
def initialize
|
||
initialize_game_battler_n03
|
||
@sv = SideView.new(self)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 現在の戦闘行動を除去
|
||
#--------------------------------------------------------------------------
|
||
alias remove_current_action_game_battler_n03 remove_current_action
|
||
def remove_current_action
|
||
return @sv.derivation_skill_id = 0 if @sv.derivation_skill_id != 0
|
||
remove_current_action_game_battler_n03
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ターン終了処理
|
||
#--------------------------------------------------------------------------
|
||
alias on_turn_end_game_battler_n03 on_turn_end
|
||
def on_turn_end
|
||
on_turn_end_game_battler_n03
|
||
@sv.add_state = []
|
||
@sv.result_damage = [@result.hp_damage, @result.mp_damage]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● パラメータ条件比較 data = [種別, 数値, 判別]
|
||
#--------------------------------------------------------------------------
|
||
def comparison_parameter(data)
|
||
return true if data[0][0] == 0
|
||
kind = data[0]
|
||
num = data[1]
|
||
select = data[2]
|
||
case kind
|
||
when 1 ; par = level
|
||
when 2 ; par = mhp
|
||
when 3 ; par = mmp
|
||
when 4 ; par = hp
|
||
when 5 ; par = mp
|
||
when 6 ; par = tp
|
||
when 7 ; par = atk
|
||
when 8 ; par = self.def
|
||
when 9 ; par = mat
|
||
when 10 ; par = mdf
|
||
when 11 ; par = agi
|
||
when 12 ; par = luk
|
||
end
|
||
if num < 0
|
||
case kind
|
||
when 4 ; num = mhp * num / 100
|
||
when 5 ; num = mmp * num / 100
|
||
when 6 ; num = max_tp * num / 100
|
||
end
|
||
num = num.abs
|
||
end
|
||
case select
|
||
when 0 ; return par == num
|
||
when 1 ; return par < num
|
||
when 2 ; return par > num
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 装備条件比較 data = [装備種別, タイプID]
|
||
#--------------------------------------------------------------------------
|
||
def comparison_equip(data)
|
||
kind = data[0]
|
||
items = weapons if kind == 0
|
||
items = armors if kind == 1
|
||
for item in items
|
||
for id in data[1]
|
||
return true if id > 0 && item.is_a?(RPG::Weapon) && item == $data_weapons[id.abs]
|
||
return true if id > 0 && item.is_a?(RPG::Armor) && item == $data_armors[id.abs]
|
||
return true if id < 0 && item.is_a?(RPG::Weapon) && item.wtype_id == id.abs
|
||
return true if id < 0 && item.is_a?(RPG::Armor) && item.stype_id == id.abs
|
||
end
|
||
end
|
||
return false
|
||
end
|
||
|
||
end
|
||
#==============================================================================
|
||
# ■ Game_Actor
|
||
#------------------------------------------------------------------------------
|
||
# アクターを扱うクラスです。
|
||
#==============================================================================
|
||
class Game_Actor < Game_Battler
|
||
#--------------------------------------------------------------------------
|
||
# ● 公開インスタンス変数
|
||
#--------------------------------------------------------------------------
|
||
attr_reader :actor_id # ID
|
||
#--------------------------------------------------------------------------
|
||
# ● ID
|
||
#--------------------------------------------------------------------------
|
||
def id
|
||
return @actor_id
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● スプライトを使うか？ ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def use_sprite?
|
||
return true
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ダメージ効果の実行 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def perform_damage_effect
|
||
return if !N03::ACTOR_DAMAGE
|
||
$game_troop.screen.start_shake(5, 5, 10)
|
||
@sprite_effect_type = :blink
|
||
Sound.play_actor_damage
|
||
end
|
||
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Game_Enemy
|
||
#------------------------------------------------------------------------------
|
||
# 敵キャラを扱うクラスです。
|
||
#==============================================================================
|
||
class Game_Enemy < Game_Battler
|
||
#--------------------------------------------------------------------------
|
||
# ● 公開インスタンス変数
|
||
#--------------------------------------------------------------------------
|
||
attr_reader :enemy_id # ID
|
||
#--------------------------------------------------------------------------
|
||
# ● ID
|
||
#--------------------------------------------------------------------------
|
||
def id
|
||
return @enemy_id
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● レベル
|
||
#--------------------------------------------------------------------------
|
||
def level
|
||
return @sv.level
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ダメージ効果の実行 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def perform_damage_effect
|
||
return if !N03::ENEMY_DAMAGE
|
||
@sprite_effect_type = :blink
|
||
Sound.play_enemy_damage
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 武器
|
||
#--------------------------------------------------------------------------
|
||
def weapons
|
||
weapon1 = $data_weapons[@sv.enemy_weapon1_id]
|
||
weapon2 = $data_weapons[@sv.enemy_weapon2_id]
|
||
return [weapon1, weapon2]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 防具
|
||
#--------------------------------------------------------------------------
|
||
def armors
|
||
return [$data_armors[@sv.enemy_shield_id]]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 二刀流の判定
|
||
#--------------------------------------------------------------------------
|
||
def dual_wield?
|
||
return $data_weapons[@sv.enemy_weapon2_id] != nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトラー画像変更
|
||
#--------------------------------------------------------------------------
|
||
def graphics_change(battler_name)
|
||
@battler_name = battler_name
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 通常攻撃 アニメーション ID の取得
|
||
#--------------------------------------------------------------------------
|
||
def atk_animation_id1
|
||
return weapons[0].animation_id if weapons[0]
|
||
return weapons[1] ? 0 : 1
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 通常攻撃 アニメーション ID の取得（二刀流：武器２）
|
||
#--------------------------------------------------------------------------
|
||
def atk_animation_id2
|
||
return weapons[1] ? weapons[1].animation_id : 0
|
||
end
|
||
end
|
||
|
||
#==============================================================================
|
||
# ■ Sprite_Base
|
||
#------------------------------------------------------------------------------
|
||
# アニメーションの表示処理を追加したスプライトのクラスです。
|
||
#==============================================================================
|
||
class Sprite_Base < Sprite
|
||
#--------------------------------------------------------------------------
|
||
# ● アニメーションの座標更新 (ホーミングあり)
|
||
#--------------------------------------------------------------------------
|
||
def update_animation_position_horming
|
||
return if @action_end_cancel
|
||
ani_ox_set if @horming
|
||
camera_zoom = $sv_camera.zoom
|
||
camera_zoom = 1 if @move_anime
|
||
kind = 1
|
||
kind = -1 if @ani_mirror && !@anime_no_mirror
|
||
cell_data = @animation.frames[@animation.frame_max - (@ani_duration + @ani_rate - 1) / @ani_rate].cell_data
|
||
for i in 0..15
|
||
@ani_sprites[i].x = (@ani_ox + cell_data[i, 1] * kind - $sv_camera.x) * camera_zoom if @ani_sprites[i] != nil && cell_data[i, 1] != nil
|
||
@ani_sprites[i].y = (@ani_oy + cell_data[i, 2] - $sv_camera.y) * camera_zoom if @ani_sprites[i] != nil && cell_data[i, 2] != nil
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アニメーション元の座標をセット
|
||
#--------------------------------------------------------------------------
|
||
def ani_ox_set
|
||
if !SceneManager.scene_is?(Scene_Battle)
|
||
@real_x = x
|
||
@real_y = y
|
||
end
|
||
@ani_ox = @real_x - ox + width / 2
|
||
@ani_oy = @real_y - oy + height / 2
|
||
@ani_oy -= height / 2 if @animation.position == 0
|
||
@ani_oy += height / 2 if @animation.position == 2
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アニメーションの更新
|
||
#--------------------------------------------------------------------------
|
||
alias update_animation_sprite_base_n03 update_animation
|
||
def update_animation
|
||
update_animation_position_horming if animation? && SceneManager.scene_is?(Scene_Battle) && @animation.position != 3
|
||
update_animation_sprite_base_n03
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アニメーションの原点設定 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def set_animation_origin
|
||
return ani_ox_set if @animation.position != 3
|
||
if viewport == nil
|
||
@ani_ox = Graphics.width / 2
|
||
@ani_oy = Graphics.height / 2
|
||
else
|
||
@ani_ox = viewport.rect.width / 2
|
||
@ani_oy = viewport.rect.height / 2
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アニメーションスプライトの設定 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def animation_set_sprites(frame)
|
||
camera_zoom = 1
|
||
camera_zoom = $sv_camera.zoom if @anime_camera_zoom && @animation.position != 3 && SceneManager.scene_is?(Scene_Battle)
|
||
camera_x = $sv_camera.x
|
||
camera_y = $sv_camera.y
|
||
camera_x = camera_y = 0 if @animation.position == 3 or !SceneManager.scene_is?(Scene_Battle)
|
||
plus_z = 5
|
||
plus_z = 1000 if @animation.position == 3
|
||
plus_z = -17 if @plus_z != nil && @plus_z == false
|
||
plus_z = -self.z + 10 if @plus_z != nil && @plus_z == false && @animation.position == 3
|
||
cell_data = frame.cell_data
|
||
@ani_sprites.each_with_index do |sprite, i|
|
||
next unless sprite
|
||
pattern = cell_data[i, 0]
|
||
if !pattern || pattern < 0
|
||
sprite.visible = false
|
||
next
|
||
end
|
||
sprite.bitmap = pattern < 100 ? @ani_bitmap1 : @ani_bitmap2
|
||
sprite.visible = true
|
||
sprite.src_rect.set(pattern % 5 * 192,
|
||
pattern % 100 / 5 * 192, 192, 192)
|
||
if @ani_mirror && !@anime_no_mirror
|
||
sprite.x = (@ani_ox - cell_data[i, 1] - camera_x) * camera_zoom
|
||
sprite.y = (@ani_oy + cell_data[i, 2] - camera_y) * camera_zoom
|
||
sprite.angle = (360 - cell_data[i, 4])
|
||
sprite.mirror = (cell_data[i, 5] == 0)
|
||
else
|
||
sprite.x = (@ani_ox + cell_data[i, 1] - camera_x) * camera_zoom
|
||
sprite.y = (@ani_oy + cell_data[i, 2] - camera_y) * camera_zoom
|
||
sprite.angle = cell_data[i, 4]
|
||
sprite.mirror = (cell_data[i, 5] == 1)
|
||
end
|
||
sprite.z = self.z + plus_z + i
|
||
sprite.ox = 96
|
||
sprite.oy = 96
|
||
sprite.zoom_x = cell_data[i, 3] * camera_zoom / 100.0
|
||
sprite.zoom_y = cell_data[i, 3] * camera_zoom/ 100.0
|
||
sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
|
||
sprite.blend_type = cell_data[i, 7]
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 子スプライトフラグ
|
||
#--------------------------------------------------------------------------
|
||
def set(battler, horming, camera_zoom, no_mirror)
|
||
@battler = battler
|
||
@next = true
|
||
self.bitmap = Bitmap.new(@battler.sv.cw, @battler.sv.ch)
|
||
self.ox = bitmap.width / 2
|
||
self.oy = bitmap.height
|
||
@horming = horming
|
||
@anime_camera_zoom = camera_zoom
|
||
@anime_no_mirror = no_mirror
|
||
@battler.sv.reset_anime_data
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 子スプライト座標セット
|
||
#--------------------------------------------------------------------------
|
||
def set_position(z, zoom_x, zoom_y, real_x, real_y)
|
||
self.z = z
|
||
self.zoom_x = zoom_x
|
||
self.zoom_y = zoom_y
|
||
@real_x = real_x
|
||
@real_y = real_y
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 他スプライトへのタイミング処理
|
||
#--------------------------------------------------------------------------
|
||
def other_process_timing(timing)
|
||
se_flag = true
|
||
se_flag = @se_flag if @se_flag != nil
|
||
@battler.sv.timing.push([se_flag, timing.dup])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 他バトラーへのタイミング処理
|
||
#--------------------------------------------------------------------------
|
||
def target_battler_process_timing(timing)
|
||
for target in @timing_targets
|
||
target.sv.timing.push([false, timing.dup])
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● SE とフラッシュのタイミング処理
|
||
#--------------------------------------------------------------------------
|
||
alias animation_process_timing_sprite_base_n03 animation_process_timing
|
||
def animation_process_timing(timing)
|
||
target_battler_process_timing(timing) if @timing_targets && @timing_targets != []
|
||
return other_process_timing(timing) if @next != nil
|
||
animation_process_timing_sprite_base_n03(timing)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アニメーションの解放
|
||
#--------------------------------------------------------------------------
|
||
alias dispose_animation_sprite_base_n03 dispose_animation
|
||
def dispose_animation
|
||
dispose_animation_sprite_base_n03
|
||
end
|
||
end
|
||
|
||
|
||
#==============================================================================
|
||
# ■ Sprite_Battler
|
||
#------------------------------------------------------------------------------
|
||
# バトラー表示用のスプライトです。
|
||
#==============================================================================
|
||
class Sprite_Battler < Sprite_Base
|
||
#--------------------------------------------------------------------------
|
||
# ● 公開インスタンス変数
|
||
#--------------------------------------------------------------------------
|
||
attr_accessor :removing # パーティ離脱中
|
||
#--------------------------------------------------------------------------
|
||
# ● オブジェクト初期化
|
||
#--------------------------------------------------------------------------
|
||
alias initialize_sprite_battler_n03 initialize
|
||
def initialize(viewport, battler = nil)
|
||
initialize_sprite_battler_n03(viewport, battler)
|
||
@real_x = @real_y = 0
|
||
update_bitmap if @battler != nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アニメーションの開始 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def start_animation(animation, mirror = false)
|
||
return next_animation(animation, mirror) if animation?
|
||
@animation = animation
|
||
if @animation
|
||
@horming = @battler.sv.anime_horming
|
||
@anime_camera_zoom = @battler.sv.anime_camera_zoom
|
||
@anime_no_mirror = @battler.sv.anime_no_mirror
|
||
@timing_targets = @battler.sv.timing_targets
|
||
@plus_z = @battler.sv.anime_plus_z
|
||
@battler.sv.reset_anime_data
|
||
@ani_mirror = mirror
|
||
set_animation_rate
|
||
@ani_duration = @animation.frame_max * @ani_rate + 1
|
||
load_animation_bitmap
|
||
make_animation_sprites
|
||
set_animation_origin
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 次のアニメを開始
|
||
#--------------------------------------------------------------------------
|
||
def next_animation(animation, mirror)
|
||
@next_anime = [] if @next_anime == nil
|
||
@next_anime.push(Sprite_Base.new(viewport))
|
||
@next_anime[@next_anime.size - 1].set(battler, @battler.sv.anime_horming, @battler.sv.anime_camera_zoom, @battler.sv.anime_no_mirror)
|
||
@next_anime[@next_anime.size - 1].set_position(self.z, self.zoom_x, self.zoom_y, @real_x, @real_y)
|
||
@next_anime[@next_anime.size - 1].start_animation(animation, mirror)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 影グラフィック作成
|
||
#--------------------------------------------------------------------------
|
||
def create_shadow
|
||
reset_shadow
|
||
return if @battler.sv.shadow == false
|
||
@shadow = Sprite.new(viewport) if @shadow == nil
|
||
@shadow.bitmap = Cache.character(@battler.sv.shadow)
|
||
@shadow.ox = @shadow.bitmap.width / 2
|
||
@shadow.oy = @shadow.bitmap.height / 2
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 影グラフィック初期化
|
||
#--------------------------------------------------------------------------
|
||
def reset_shadow
|
||
return if @shadow == nil
|
||
@shadow.dispose
|
||
@shadow = nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 転送元ビットマップの更新 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def update_bitmap
|
||
update_bitmap_enemy if !@battler.actor?
|
||
update_bitmap_actor if @battler.actor?
|
||
update_src_rect if @battler != nil
|
||
update_color if @battler != nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 転送元ビットマップ:エネミー
|
||
#--------------------------------------------------------------------------
|
||
def update_bitmap_enemy
|
||
if @battler.battler_name != @battler_name or @battler.battler_hue != @battler_hue
|
||
@battler_name = @battler.battler_name
|
||
@battler_hue = @battler.battler_hue
|
||
@battler_graphic_file_index = @battler.sv.graphic_file_index
|
||
@graphic_mirror_flag = @battler.sv.graphic_mirror_flag
|
||
self.bitmap = Cache.battler(@battler_name + @battler_graphic_file_index, @battler_hue)
|
||
@battler.sv.setup(self.bitmap.width, self.bitmap.height, @battler_id != @battler.id)
|
||
create_shadow
|
||
init_visibility
|
||
@battler_id = @battler.id
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 転送元ビットマップ:アクター
|
||
#--------------------------------------------------------------------------
|
||
def update_bitmap_actor
|
||
if @battler.character_name != @battler_name or @battler.character_index != @battler_index
|
||
@battler_name = @battler.character_name
|
||
@battler_index = @battler.character_index
|
||
@battler_graphic_file_index = @battler.sv.graphic_file_index
|
||
@graphic_mirror_flag = @battler.sv.graphic_mirror_flag
|
||
self.bitmap = Cache.character(@battler_name + @battler_graphic_file_index)
|
||
@battler.sv.setup(self.bitmap.width, self.bitmap.height, @battler_id != @battler.id)
|
||
create_shadow
|
||
init_visibility
|
||
@battler_id = @battler.id
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 可視状態の初期化 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def init_visibility
|
||
@battler_visible = @battler.alive?
|
||
@battler_visible = true if @battler.sv.state(1) != "敵コラプス"
|
||
@battler_visible = false if @battler.hidden?
|
||
@battler.sv.opacity = 0 unless @battler_visible
|
||
self.opacity = 0 unless @battler_visible
|
||
self.opacity = 255 if @battler_visible
|
||
@battler.sv.weapon_visible = @battler_visible
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 転送元矩形の更新
|
||
#--------------------------------------------------------------------------
|
||
def update_src_rect
|
||
return if @battler.sv.collapse
|
||
if @battler_graphic_file_index != @battler.sv.graphic_file_index
|
||
@battler_graphic_file_index = @battler.sv.graphic_file_index
|
||
self.bitmap = Cache.character(@battler_name + @battler_graphic_file_index) if @battler.actor?
|
||
self.bitmap = Cache.battler(@battler_name + @battler_graphic_file_index, @battler_hue) if !@battler.actor?
|
||
@battler.sv.set_graphics(self.bitmap.width, self.bitmap.height)
|
||
end
|
||
anime_off if @battler.sv.anime_off
|
||
self.src_rect.set(@battler.sv.sx, @battler.sv.sy, @battler.sv.cw, @battler.sv.ch)
|
||
self.opacity = @battler.sv.opacity if @battler_visible
|
||
set_process_timing(@battler.sv.timing) if @battler && @battler.sv.timing != []
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 位置の更新 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def update_position
|
||
@real_x = @battler.sv.x / 100
|
||
@real_y = (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.c - @battler.sv.oy_adjust)/ 100
|
||
self.x = @real_x - $sv_camera.x
|
||
self.y = @real_y - $sv_camera.y
|
||
self.z = @battler.sv.z - @battler.sv.c / 100
|
||
if @battler.sv.h <= 0
|
||
self.x += $sv_camera.sx / 100
|
||
self.y += $sv_camera.sy / 100
|
||
end
|
||
self.x *= $sv_camera.zoom
|
||
self.y *= $sv_camera.zoom
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 原点の更新 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def update_origin
|
||
return if !bitmap or @battler.sv.collapse
|
||
self.ox = @battler.sv.ox
|
||
self.oy = @battler.sv.oy
|
||
self.angle = @battler.sv.angle
|
||
self.zoom_x = @battler.sv.zoom_x * $sv_camera.zoom
|
||
self.zoom_y = @battler.sv.zoom_y * $sv_camera.zoom
|
||
self.mirror = @battler.sv.mirror if !@graphic_mirror_flag
|
||
self.mirror = !@battler.sv.mirror if @graphic_mirror_flag
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 影グラフィックの更新
|
||
#--------------------------------------------------------------------------
|
||
def update_shadow
|
||
@shadow.visible = @battler.sv.shadow_visible
|
||
@shadow.opacity = @battler.sv.opacity if @battler.sv.opacity_data[3]
|
||
@shadow.opacity = self.opacity if !@battler.sv.opacity_data[3]
|
||
@shadow.x = @real_x - $sv_camera.x
|
||
@shadow.y = (@battler.sv.y - @battler.sv.c)/ 100 - $sv_camera.y
|
||
@shadow.z = @battler.sv.z - 10
|
||
@shadow.zoom_x = $sv_camera.zoom
|
||
@shadow.zoom_y = $sv_camera.zoom
|
||
@shadow.x += $sv_camera.sx / 100
|
||
@shadow.y += $sv_camera.sy / 100
|
||
@shadow.x *= $sv_camera.zoom
|
||
@shadow.y *= $sv_camera.zoom
|
||
@shadow.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ふきだしの更新
|
||
#--------------------------------------------------------------------------
|
||
def update_balloon
|
||
if @battler.sv.balloon_data == [] && @balloon
|
||
@balloon_data = []
|
||
@balloon.dispose
|
||
return @balloon = nil
|
||
elsif @battler.sv.balloon_data != [] && @battler.sv.balloon_data != @balloon_data
|
||
@balloon_data = @battler.sv.balloon_data
|
||
@balloon = Sprite.new(self.viewport)
|
||
@balloon.bitmap = Cache.system("Balloon")
|
||
@balloon.zoom_x = @balloon_data[3]
|
||
@balloon.zoom_y = @balloon_data[3]
|
||
@balloon.ox = 32 if @battler.sv.mirror
|
||
@balloon.oy = 16
|
||
@balloon_count = 0
|
||
end
|
||
return if !@balloon
|
||
@balloon.opacity = self.opacity
|
||
@balloon.x = self.x
|
||
@balloon.y = self.y - @battler.sv.ch * $sv_camera.zoom
|
||
@balloon.z = self.z + 20
|
||
@balloon.src_rect.set(32 + @balloon_count / @balloon_data[2] * 32, @balloon_data[1] * 32, 32, 32) if @balloon_count % @balloon_data[2] == 0
|
||
@balloon.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
|
||
@balloon_count += 1
|
||
@balloon_count = 0 if @balloon_count == @balloon_data[2] * 7
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 色調変更の更新
|
||
#--------------------------------------------------------------------------
|
||
def update_color
|
||
color_set if @battler.sv.color_set != []
|
||
return if @color_data == nil
|
||
@color_data[4] -= 1
|
||
if @color_data[4] == 0 && @color_data[5] != 0
|
||
@color_data[4] = @color_data[5]
|
||
@color_data[5] = 0
|
||
@color_data[6] = [0,0,0,0]
|
||
elsif @color_data[4] == 0
|
||
@remain_color_data = @color_data
|
||
@battler.sv.color = @color_data.dup
|
||
return @color_data = nil
|
||
end
|
||
for i in 0..3
|
||
@color_data[i] = (@color_data[i] * (@color_data[4] - 1) + @color_data[6][i]) / @color_data[4]
|
||
end
|
||
@battler.sv.color = @color_data.dup
|
||
self.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 残像の更新
|
||
#--------------------------------------------------------------------------
|
||
def update_mirage
|
||
if @battler.sv.mirage == [] && @mirages
|
||
@mirage_data = []
|
||
for mirage in @mirages do mirage.dispose end
|
||
return @mirages = nil
|
||
elsif @battler.sv.mirage != [] && @battler.sv.mirage != @mirage_data
|
||
@mirage_data = @battler.sv.mirage
|
||
@mirages = []
|
||
for i in 0...@mirage_data[1] do @mirages[i] = Sprite.new(self.viewport) end
|
||
@mirage_count = 0
|
||
end
|
||
return if !@mirages
|
||
@mirage_count += 1
|
||
@mirage_count = 0 if @mirage_count == @mirage_data[2] * @mirages.size
|
||
for i in 0...@mirages.size
|
||
mirage_body(@mirages[i], @mirage_data[4]) if @mirage_count == 1 + i * @mirage_data[2]
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 残像本体
|
||
#--------------------------------------------------------------------------
|
||
def mirage_body(body, opacity)
|
||
body.bitmap = self.bitmap.dup
|
||
body.x = self.x
|
||
body.y = self.y
|
||
body.ox = self.ox
|
||
body.oy = self.oy
|
||
body.z = self.z - 20
|
||
body.mirror = self.mirror
|
||
body.angle = self.angle
|
||
body.opacity = opacity * self.opacity / 255
|
||
body.zoom_x = self.zoom_x
|
||
body.zoom_y = self.zoom_y
|
||
body.src_rect.set(@battler.sv.sx, @battler.sv.sy, @battler.sv.cw, @battler.sv.ch)
|
||
body.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 次のアニメを更新
|
||
#--------------------------------------------------------------------------
|
||
def update_next_anime
|
||
return if !@next_anime
|
||
for anime in @next_anime
|
||
anime.update
|
||
anime.set_position(self.z, self.zoom_x, self.zoom_y, @real_x, @real_y) if @horming
|
||
anime.dispose if !anime.animation?
|
||
@next_anime.delete(anime) if !anime.animation?
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● フレーム更新
|
||
#--------------------------------------------------------------------------
|
||
alias update_sprite_battler_n03 update
|
||
def update
|
||
@battler.sv.update if @battler
|
||
update_sprite_battler_n03
|
||
update_next_anime
|
||
update_shadow if @battler && @shadow
|
||
update_mirage if @battler
|
||
update_balloon if @battler
|
||
update_remove if @battler && @removing && @battler.sv.change_up
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 戦闘アニメ消去
|
||
#--------------------------------------------------------------------------
|
||
def anime_off
|
||
@battler.sv.anime_off = false
|
||
dispose_animation
|
||
for anime in @next_anime do anime.dispose_animation end if @next_anime
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトラー入れ替え
|
||
#--------------------------------------------------------------------------
|
||
def remove
|
||
@battler.sv.start_action(@battler.sv.remove_action)
|
||
$sv_camera.wait = 40
|
||
@battler.sv.add_action("eval('set_change')")
|
||
@removing = true
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトラー入れ替えの更新
|
||
#--------------------------------------------------------------------------
|
||
def update_remove
|
||
@battler.sv.change_up = false
|
||
@removing = false
|
||
@battler = nil
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトラー加入
|
||
#--------------------------------------------------------------------------
|
||
def join(join_battler)
|
||
$sv_camera.wait = 30
|
||
@battler = join_battler
|
||
@battler_name = @battler.character_name
|
||
@battler_index = @battler.character_index
|
||
@battler_graphic_file_index = @battler.sv.graphic_file_index
|
||
self.bitmap = Cache.character(@battler_name)
|
||
@battler.sv.setup(self.bitmap.width, self.bitmap.height, true)
|
||
create_shadow
|
||
init_visibility
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 通常の設定に戻す ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def revert_to_normal
|
||
self.blend_type = 0
|
||
self.opacity = 255
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 崩壊エフェクトの更新
|
||
#--------------------------------------------------------------------------
|
||
alias update_collapse_sprite_battler_n03 update_collapse
|
||
def update_collapse
|
||
return if @battler.sv.state(1) != "敵コラプス"
|
||
update_collapse_sprite_battler_n03
|
||
@battler.sv.weapon_visible = false
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ボス崩壊エフェクトの更新 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def update_boss_collapse
|
||
@effect_duration = @battler.sv.ch if @effect_duration >= @battler.sv.ch
|
||
alpha = @effect_duration * 120 / @battler.sv.ch
|
||
self.ox = @battler.sv.cw / 2 + @effect_duration % 2 * 4 - 2
|
||
self.blend_type = 1
|
||
self.color.set(255, 255, 255, 255 - alpha)
|
||
self.opacity = alpha
|
||
self.src_rect.y -= 1
|
||
Sound.play_boss_collapse2 if @effect_duration % 20 == 19
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 別スプライトからのタイミング処理
|
||
#--------------------------------------------------------------------------
|
||
def set_process_timing(timing_data)
|
||
for data in timing_data
|
||
set_timing(data[0],data[1])
|
||
end
|
||
@battler.sv.timing = []
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● タイミング処理
|
||
#--------------------------------------------------------------------------
|
||
def set_timing(se_flag, data)
|
||
@ani_rate = 4
|
||
data.se.play if se_flag
|
||
case data.flash_scope
|
||
when 1 ;self.flash(data.flash_color, data.flash_duration * @ani_rate)
|
||
when 2 ;viewport.flash(data.flash_color, data.flash_duration * @ani_rate) if viewport
|
||
when 3 ;self.flash(nil, data.flash_duration * @ani_rate)
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 色調変更
|
||
#--------------------------------------------------------------------------
|
||
def color_set
|
||
set = @battler.sv.color_set
|
||
@battler.sv.color_set= []
|
||
set[4] = 1 if set[4] == 0
|
||
@remain_color_data = [0,0,0,0] if @remain_color_data == nil
|
||
@color_data = @remain_color_data
|
||
@color_data[4] = set[4]
|
||
@color_data[5] = set[5]
|
||
@color_data[6] = set
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 解放
|
||
#--------------------------------------------------------------------------
|
||
alias dispose_sprite_battler_n03 dispose
|
||
def dispose
|
||
dispose_sprite_battler_n03
|
||
@shadow.dispose if @shadow != nil
|
||
@balloon.dispose if @balloon != nil
|
||
for mirage in @mirages do mirage.dispose end if @mirages != nil
|
||
for anime in @next_anime do anime.dispose end if @next_anime
|
||
end
|
||
end
|
||
|
||
|
||
#==============================================================================
|
||
# ■ Spriteset_Battle
|
||
#------------------------------------------------------------------------------
|
||
# バトル画面のスプライトをまとめたクラスです。
|
||
#==============================================================================
|
||
class Spriteset_Battle
|
||
#--------------------------------------------------------------------------
|
||
# ● 戦闘背景（床）スプライトの作成 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def create_battleback1
|
||
@back1_sprite = Sprite_Battle_Back.new(@viewport1, 1, battleback1_name)
|
||
@back1_sprite.set_graphics(battleback1_bitmap) if battleback1_name != nil
|
||
@back1_sprite.z = 0
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 戦闘背景（壁）スプライトの作成 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def create_battleback2
|
||
@back2_sprite = Sprite_Battle_Back.new(@viewport1, 2, battleback2_name)
|
||
@back2_sprite.set_graphics(battleback2_bitmap) if battleback2_name != nil
|
||
@back2_sprite.z = 1
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アクタースプライトの作成 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def create_actors
|
||
@actor_sprites = []
|
||
for i in 0...$game_party.max_battle_members
|
||
@actor_sprites[i] = Sprite_Battler.new(@viewport1, $game_party.members[i])
|
||
end
|
||
@effect_sprites = Spriteset_Sideview.new(@viewport1)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● アクタースプライトの更新 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def update_actors
|
||
@actor_sprites.each_with_index do |sprite, i|
|
||
sprite_join($game_party.members[i], sprite) if sprite.battler == nil && sprite.battler != $game_party.members[i]
|
||
sprite.remove if sprite.battler != nil && !sprite.removing && sprite.battler != $game_party.members[i]
|
||
sprite.update
|
||
end
|
||
@effect_sprites.update
|
||
update_program
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● メンバーを加える
|
||
#--------------------------------------------------------------------------
|
||
def sprite_join(member, sprite)
|
||
for sp in @actor_sprites
|
||
sp.update_remove if member == sp.battler && !sp.battler.sv.change_up
|
||
end
|
||
sprite.join(member)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● バトルプログラムの更新
|
||
#--------------------------------------------------------------------------
|
||
def update_program
|
||
return if $sv_camera.program_scroll == []
|
||
for data in $sv_camera.program_scroll
|
||
@back1_sprite.start_back_data(data) if data[2] == 1
|
||
@back2_sprite.start_back_data(data) if data[2] == 2
|
||
end
|
||
$sv_camera.program_scroll = []
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ヒット時の戦闘アニメ実行
|
||
#--------------------------------------------------------------------------
|
||
def set_hit_animation(battler, weapon_index, hit_targets, miss)
|
||
@effect_sprites.set_hit_animation(battler, weapon_index, hit_targets, miss)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ダメージPOP
|
||
#--------------------------------------------------------------------------
|
||
def set_damage_pop(target)
|
||
@effect_sprites.set_damage_pop(target)
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 解放
|
||
#--------------------------------------------------------------------------
|
||
alias dispose_spriteset_battle_n03 dispose
|
||
def dispose
|
||
dispose_spriteset_battle_n03
|
||
@effect_sprites.dispose
|
||
end
|
||
|
||
|
||
|
||
end
|
||
|
||
|
||
#==============================================================================
|
||
# ■ Window_BattleLog
|
||
#------------------------------------------------------------------------------
|
||
# 戦闘の進行を実況表示するウィンドウです。
|
||
#==============================================================================
|
||
class Window_BattleLog < Window_Selectable
|
||
#--------------------------------------------------------------------------
|
||
# ● ウェイト ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def wait
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ウェイトとクリア ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def wait_and_clear
|
||
$sv_camera.wait = 10
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● 行動結果の表示 ★再定義
|
||
#--------------------------------------------------------------------------
|
||
def display_action_results(target, item)
|
||
if target.result.used
|
||
last_line_number = line_number
|
||
display_critical(target, item)
|
||
display_steal(target, item)#紅茶走
|
||
display_damage(target, item)
|
||
display_affected_status(target, item)
|
||
display_failure(target, item)
|
||
end
|
||
off if !N03::BATTLE_LOG
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ● ウインドウ非表示
|
||
#--------------------------------------------------------------------------
|
||
def off
|
||
@back_sprite.visible = self.visible = false
|
||
end
|
||
end
|
||
#==============================================================================
|
||
# ■ Game_Interpreter
|
||
#------------------------------------------------------------------------------
|
||
# イベントコマンドを実行するインタプリタです。
|
||
#==============================================================================
|
||
class Game_Interpreter
|
||
#--------------------------------------------------------------------------
|
||
# ● スイッチの操作
|
||
#--------------------------------------------------------------------------
|
||
alias command_121_game_interpreter_n03 command_121
|
||
def command_121
|
||
command_121_game_interpreter_n03
|
||
$sv_camera.program_check
|
||
end
|
||
end |