复制了一个横版战斗系统，但是出错了 - Project1

$脸图战斗 = true
$imported = {} if $imported.nil?
module YEA
module BATTLE
SKIP_PARTY_COMMAND = true
BATTLESTATUS_NAME_FONT_SIZE = 20
BATTLESTATUS_TEXT_FONT_SIZE = 16
BATTLESTATUS_NO_ACTION_ICON = 185
BATTLESTATUS_HPGAUGE_Y_PLUS = 11
BATTLESTATUS_CENTER_FACES = false
HELP_TEXT_ALL_FOES = "全体敌人"
HELP_TEXT_ONE_RANDOM_FOE = "单个敌人"
HELP_TEXT_MANY_RANDOM_FOE = "%d个随机敌人"
HELP_TEXT_ALL_ALLIES = "全体队友"
HELP_TEXT_ALL_DEAD_ALLIES = "全体死亡队友"
HELP_TEXT_ONE_RANDOM_ALLY = "单个随机队友"
HELP_TEXT_RANDOM_ALLIES = "%d个随机队友"
end
end
class Game_Battler
def can_collapse?
return false unless dead?
unless actor?
return false unless sprite.battler_visible
array = [:collapse, :boss_collapse, :instant_collapse]
return false if array.include?(sprite.effect_type)
end
return true
end
def draw_mp?
return true
end
def draw_tp?
return $data_system.opt_display_tp
end
end
module Icon
def self.no_action; return YEA::BATTLE::BATTLESTATUS_NO_ACTION_ICON; end
end
class Game_Temp
attr_accessor :battle_aid
attr_accessor :evaluating
end
class Game_Action
alias evaluate_item_with_target_abe evaluate_item_with_target
def evaluate_item_with_target(target)
$game_temp.evaluating = true
result = evaluate_item_with_target_abe(target)
$game_temp.evaluating = false
return result
end
end
class Game_Actor < Game_Battler
def draw_mp?
return true unless draw_tp?
for skill in skills
next unless added_skill_types.include?(skill.stype_id)
return true if skill.mp_cost > 0
end
return false
end
def draw_tp?
return false unless $data_system.opt_display_tp
for skill in skills
next unless added_skill_types.include?(skill.stype_id)
return true if skill.tp_cost > 0
end
return false
end
end
class Window_BattleStatus < Window_Selectable
def initialize
super(0, 0, window_width, window_height)
self.openness = 0
@party = $game_party.battle_members.clone
end
def col_max; return $game_party.max_battle_members; end
def battle_members; return $game_party.battle_members; end
def actor; return battle_members[@index]; end
def update
super
return if @party == $game_party.battle_members
@party = $game_party.battle_members.clone
refresh
end
def draw_item(index)
return if index.nil?
clear_item(index)
actor = battle_members[index]
rect = item_rect(index)
return if actor.nil?
draw_actor_face(actor, rect.x+2, rect.y+2, actor.alive?)
draw_actor_name(actor, rect.x, rect.y, rect.width-8)
draw_actor_action(actor, rect.x, rect.y)
draw_actor_icons(actor, rect.x, line_height*1, rect.width)
gx = YEA::BATTLE::BATTLESTATUS_HPGAUGE_Y_PLUS
contents.font.size = YEA::BATTLE::BATTLESTATUS_TEXT_FONT_SIZE
draw_actor_hp(actor, rect.x+2, line_height*2+gx, rect.width-4)
if draw_tp?(actor) && draw_mp?(actor)
dw = rect.width/2-2
dw += 1 if $imported["YEA-CoreEngine"] && YEA::CORE::GAUGE_OUTLINE
draw_actor_tp(actor, rect.x+2, line_height*3, dw)
dw = rect.width - rect.width/2 - 2
draw_actor_mp(actor, rect.x+rect.width/2, line_height*3, dw)
elsif draw_tp?(actor) && !draw_mp?(actor)
draw_actor_tp(actor, rect.x+2, line_height*3, rect.width-4)
else
draw_actor_mp(actor, rect.x+2, line_height*3, rect.width-4)
end
end
def item_rect(index)
rect = Rect.new
rect.width = contents.width / $game_party.max_battle_members
rect.height = contents.height
rect.x = index * rect.width
if YEA::BATTLE::BATTLESTATUS_CENTER_FACES
rect.x += (contents.width - $game_party.members.size * rect.width) / 2
end
rect.y = 0
return rect
end
def draw_face(face_name, face_index, dx, dy, enabled = true)
bitmap = Cache.face(face_name)
fx = [(96 - item_rect(0).width + 1) / 2, 0].max
fy = face_index / 4 * 96 + 2
fw = [item_rect(0).width - 4, 92].min
rect = Rect.new(fx, fy, fw, 92)
rect = Rect.new(face_index % 4 * 96 + fx, fy, fw, 92)
contents.blt(dx, dy, bitmap, rect, enabled ? 255 : translucent_alpha)
bitmap.dispose
end
def draw_actor_name(actor, dx, dy, dw = 112)
reset_font_settings
contents.font.size = YEA::BATTLE::BATTLESTATUS_NAME_FONT_SIZE
change_color(hp_color(actor))
draw_text(dx+24, dy, dw-24, line_height, actor.name)
end
def draw_actor_action(actor, dx, dy)
draw_icon(action_icon(actor), dx, dy)
end
def action_icon(actor)
return Icon.no_action if actor.current_action.nil?
return Icon.no_action if actor.current_action.item.nil?
return actor.current_action.item.icon_index
end
def draw_tp?(actor)
return actor.draw_tp?
end
def draw_mp?(actor)
return actor.draw_mp?
end
def draw_current_and_max_values(dx, dy, dw, current, max, color1, color2)
change_color(color1)
draw_text(dx, dy, dw, line_height, current.to_s, 2)
end
def draw_actor_hp(actor, dx, dy, width = 124)
draw_gauge(dx, dy, width, actor.hp_rate, hp_gauge_color1, hp_gauge_color2)
change_color(system_color)
cy = (Font.default_size - contents.font.size) / 2 + 1
draw_text(dx+2, dy+cy, 30, line_height, Vocab::hp_a)
draw_current_and_max_values(dx, dy+cy, width, actor.hp, actor.mhp,
hp_color(actor), normal_color)
end
def draw_actor_mp(actor, dx, dy, width = 124)
draw_gauge(dx, dy, width, actor.mp_rate, mp_gauge_color1, mp_gauge_color2)
change_color(system_color)
cy = (Font.default_size - contents.font.size) / 2 + 1
draw_text(dx+2, dy+cy, 30, line_height, Vocab::mp_a)
draw_current_and_max_values(dx, dy+cy, width, actor.mp, actor.mmp,
mp_color(actor), normal_color)
end
def draw_actor_tp(actor, dx, dy, width = 124)
draw_gauge(dx, dy, width, actor.tp_rate, tp_gauge_color1, tp_gauge_color2)
change_color(system_color)
cy = (Font.default_size - contents.font.size) / 2 + 1
draw_text(dx+2, dy+cy, 30, line_height, Vocab::tp_a)
change_color(tp_color(actor))
draw_text(dx + width - 42, dy+cy, 42, line_height, actor.tp.to_i, 2)
end
end
class Window_BattleActor < Window_BattleStatus
def show
create_flags
super
end
def create_flags
set_select_flag(:any)
select(0)
return if $game_temp.battle_aid.nil?
if $game_temp.battle_aid.need_selection?
select(0)
set_select_flag(:dead) if $game_temp.battle_aid.for_dead_friend?
elsif $game_temp.battle_aid.for_user?
battler = BattleManager.actor
id = battler.nil? ? 0 : $game_party.battle_members.index(battler)
select(id)
set_select_flag(:user)
elsif $game_temp.battle_aid.for_all?
select(0)
set_select_flag(:all)
set_select_flag(:all_dead) if $game_temp.battle_aid.for_dead_friend?
elsif $game_temp.battle_aid.for_random?
select(0)
set_select_flag(:random) if $game_temp.battle_aid.for_random?
end
end
def set_select_flag(flag)
@select_flag = flag
case @select_flag
when :all, :all_dead, :random
@cursor_all = true
else
@cursor_all = false
end
end
def update_cursor
if @cursor_all
cursor_rect.set(0, 0, contents.width, contents.height)
self.top_row = 0
elsif @index < 0
cursor_rect.empty
else
ensure_cursor_visible
cursor_rect.set(item_rect(@index))
end
end
def cursor_movable?
return false if @select_flag == :user
return super
end
def current_item_enabled?
return true if $game_temp.battle_aid.nil?
if $game_temp.battle_aid.need_selection?
member = $game_party.battle_members[@index]
return member.dead? if $game_temp.battle_aid.for_dead_friend?
elsif $game_temp.battle_aid.for_dead_friend?
for member in $game_party.battle_members
return true if member.dead?
end
return false
end
return true
end
end
class Window_BattleStatusAid < Window_BattleStatus
attr_accessor :status_window
def initialize
super
self.visible = false
self.openness = 255
end
def window_width; return 128; end
def show
super
refresh
end
def refresh
contents.clear
return if @status_window.nil?
draw_item(@status_window.index)
end
def item_rect(index)
return Rect.new(0, 0, contents.width, contents.height)
end
end
class Window_BattleEnemy < Window_Selectable
def initialize(info_viewport)
super(0, Graphics.height, window_width, fitting_height(1))
refresh
self.visible = false
@info_viewport = info_viewport
end
def col_max; return item_max; end
def show
create_flags
super
end
def create_flags
set_select_flag(:any)
select(0)
return if $game_temp.battle_aid.nil?
if $game_temp.battle_aid.need_selection?
select(0)
elsif $game_temp.battle_aid.for_all?
select(0)
set_select_flag(:all)
elsif $game_temp.battle_aid.for_random?
select(0)
set_select_flag(:random)
end
end
def set_select_flag(flag)
@select_flag = flag
case @select_flag
when :all, :random
@cursor_all = true
else
@cursor_all = false
end
end
def select_all?
return true if @select_flag == :all
return true if @select_flag == :random
return false
end
def update_cursor
if @cursor_all
cursor_rect.set(0, 0, contents.width, contents.height)
self.top_row = 0
elsif @index < 0
cursor_rect.empty
else
ensure_cursor_visible
cursor_rect.set(item_rect(@index))
end
end
def cursor_movable?
return false if @select_flag == :user
return super
end
def current_item_enabled?
return true if $game_temp.battle_aid.nil?
if $game_temp.battle_aid.need_selection?
member = $game_party.battle_members[@index]
return member.dead? if $game_temp.battle_aid.for_dead_friend?
elsif $game_temp.battle_aid.for_dead_friend?
for member in $game_party.battle_members
return true if member.dead?
end
return false
end
return true
end
def enemy; @data[index]; end
def refresh
make_item_list
create_contents
draw_all_items
end
def make_item_list
@data = $game_troop.alive_members
@data.sort! { |a,b| a.screen_x <=> b.screen_x }
end
def draw_item(index); return; end
def update
super
return unless active
enemy.sprite_effect_type = :whiten
return unless select_all?
for enemy in $game_troop.alive_members
enemy.sprite_effect_type = :whiten
end
end
end
class Window_BattleHelp < Window_Help
attr_accessor :actor_window
attr_accessor :enemy_window
def update
super
if !self.visible and @text != ""
@text = ""
return refresh
end
update_battler_name
end
def update_battler_name
return unless @actor_window.active || @enemy_window.active
if @actor_window.active
battler = $game_party.battle_members[@actor_window.index]
elsif @enemy_window.active
battler = @enemy_window.enemy
end
if special_display?
refresh_special_case(battler)
else
refresh_battler_name(battler) if battler_name(battler) != @text
end
end
def battler_name(battler)
text = battler.name.clone
return text
end
def refresh_battler_name(battler)
contents.clear
reset_font_settings
change_color(normal_color)
@text = battler_name(battler)
icons = battler.state_icons + battler.buff_icons
dy = icons.size <= 0 ? line_height / 2 : 0
draw_text(0, dy, contents.width, line_height, @text, 1)
dx = (contents.width - (icons.size * 24)) / 2
draw_actor_icons(battler, dx, line_height, contents.width)
end
def special_display?
return false if $game_temp.battle_aid.nil?
return false if $game_temp.battle_aid.for_user?
return !$game_temp.battle_aid.need_selection?
end
def refresh_special_case(battler)
if $game_temp.battle_aid.for_opponent?
if $game_temp.battle_aid.for_all?
text = YEA::BATTLE::HELP_TEXT_ALL_FOES
else
case $game_temp.battle_aid.number_of_targets
when 1
text = YEA::BATTLE::HELP_TEXT_ONE_RANDOM_FOE
else
number = $game_temp.battle_aid.number_of_targets
text = sprintf(YEA::BATTLE::HELP_TEXT_MANY_RANDOM_FOE, number)
end
end
else
if $game_temp.battle_aid.for_dead_friend?
text = YEA::BATTLE::HELP_TEXT_ALL_DEAD_ALLIES
elsif $game_temp.battle_aid.for_random?
case $game_temp.battle_aid.number_of_targets
when 1
text = YEA::BATTLE::HELP_TEXT_ONE_RANDOM_ALLY
else
number = $game_temp.battle_aid.number_of_targets
text = sprintf(YEA::BATTLE::HELP_TEXT_RANDOM_ALLIES, number)
end
else
text = YEA::BATTLE::HELP_TEXT_ALL_ALLIES
end
end
return if text == @text
@text = text
contents.clear
reset_font_settings
draw_text(0, 0, contents.width, line_height*2, @text, 1)
end
end
class Window_SkillList < Window_Selectable
def spacing
return 8 if $game_party.in_battle
return super
end
end
class Window_ItemList < Window_Selectable
def spacing
return 8 if $game_party.in_battle
return super
end
end
class Scene_Battle < Scene_Base
attr_accessor :enemy_window
attr_accessor :info_viewport
attr_accessor :spriteset
attr_accessor :status_window
attr_accessor :status_aid_window
attr_accessor :subject
alias scene_battle_create_all_windows_abe create_all_windows
def create_all_windows
scene_battle_create_all_windows_abe
create_battle_status_aid_window
set_help_window
end
alias scene_battle_create_info_viewport_abe create_info_viewport
def create_info_viewport
scene_battle_create_info_viewport_abe
@status_window.refresh
end
def create_battle_status_aid_window
@status_aid_window = Window_BattleStatusAid.new
@status_aid_window.status_window = @status_window
@status_aid_window.x = Graphics.width - @status_aid_window.width
@status_aid_window.y = Graphics.height - @status_aid_window.height
end
def create_help_window
@help_window = Window_BattleHelp.new
@help_window.hide
end
def set_help_window
@help_window.actor_window = @actor_window
@help_window.enemy_window = @enemy_window
end
alias scene_battle_create_skill_window_abe create_skill_window
def create_skill_window
scene_battle_create_skill_window_abe
@skill_window.height = @info_viewport.rect.height
@skill_window.width = Graphics.width - @actor_command_window.width
@skill_window.y = Graphics.height - @skill_window.height
end
alias scene_battle_create_item_window_abe create_item_window
def create_item_window
scene_battle_create_item_window_abe
@item_window.height = @skill_window.height
@item_window.width = @skill_window.width
@item_window.y = Graphics.height - @item_window.height
end
alias scene_battle_next_command_abe next_command
def next_command
@status_window.show
redraw_current_status
@actor_command_window.show
@status_aid_window.hide
scene_battle_next_command_abe
end
alias scene_battle_prior_command_abe prior_command
def prior_command
redraw_current_status
scene_battle_prior_command_abe
end
def redraw_current_status
return if @status_window.index < 0
@status_window.draw_item(@status_window.index)
end
alias scene_battle_command_attack_abe command_attack
def command_attack
$game_temp.battle_aid = $data_skills[BattleManager.actor.attack_skill_id]
scene_battle_command_attack_abe
end
alias scene_battle_command_skill_abe command_skill
def command_skill
scene_battle_command_skill_abe
@status_window.hide
@actor_command_window.hide
@status_aid_window.show
end
alias scene_battle_command_item_abe command_item
def command_item
scene_battle_command_item_abe
@status_window.hide
@actor_command_window.hide
@status_aid_window.show
end
def on_skill_ok
@skill = @skill_window.item
$game_temp.battle_aid = @skill
BattleManager.actor.input.set_skill(@skill.id)
BattleManager.actor.last_skill.object = @skill
if @skill.for_opponent?
select_enemy_selection
elsif @skill.for_friend?
select_actor_selection
else
@skill_window.hide
next_command
$game_temp.battle_aid = nil
end
end
alias scene_battle_on_skill_cancel_abe on_skill_cancel
def on_skill_cancel
scene_battle_on_skill_cancel_abe
@status_window.show
@actor_command_window.show
@status_aid_window.hide
end
def on_item_ok
@item = @item_window.item
$game_temp.battle_aid = @item
BattleManager.actor.input.set_item(@item.id)
if @item.for_opponent?
select_enemy_selection
elsif @item.for_friend?
select_actor_selection
else
@item_window.hide
next_command
$game_temp.battle_aid = nil
end
$game_party.last_item.object = @item
end
alias scene_battle_on_item_cancel_abe on_item_cancel
def on_item_cancel
scene_battle_on_item_cancel_abe
@status_window.show
@actor_command_window.show
@status_aid_window.hide
end
alias scene_battle_select_actor_selection_abe select_actor_selection
def select_actor_selection
@status_aid_window.refresh
scene_battle_select_actor_selection_abe
@status_window.hide
@skill_window.hide
@item_window.hide
@help_window.show
end
alias scene_battle_on_actor_ok_abe on_actor_ok
def on_actor_ok
$game_temp.battle_aid = nil
scene_battle_on_actor_ok_abe
@status_window.show
if $imported["YEA-BattleCommandList"] && !@confirm_command_window.nil?
@actor_command_window.visible = !@confirm_command_window.visible
else
@actor_command_window.show
end
@status_aid_window.hide
end
alias scene_battle_on_actor_cancel_abe on_actor_cancel
def on_actor_cancel
BattleManager.actor.input.clear
@status_aid_window.refresh
$game_temp.battle_aid = nil
scene_battle_on_actor_cancel_abe
case @actor_command_window.current_symbol
when :skill
@skill_window.show
when :item
@item_window.show
end
end
alias scene_battle_select_enemy_selection_abe select_enemy_selection
def select_enemy_selection
@status_aid_window.refresh
scene_battle_select_enemy_selection_abe
@help_window.show
end
alias scene_battle_on_enemy_ok_abe on_enemy_ok
def on_enemy_ok
$game_temp.battle_aid = nil
scene_battle_on_enemy_ok_abe
end
alias scene_battle_on_enemy_cancel_abe on_enemy_cancel
def on_enemy_cancel
BattleManager.actor.input.clear
@status_aid_window.refresh
$game_temp.battle_aid = nil
scene_battle_on_enemy_cancel_abe
if @skill_window.visible || @item_window.visible
@help_window.show
else
@help_window.hide
end
end
def end_battle_conditions?
return true if $game_party.members.empty?
return true if $game_party.all_dead?
return true if $game_troop.all_dead?
return true if BattleManager.aborting?
return false
end
def refresh_status
#如果你是程序员，请顺手帮忙优化下这里，谢谢。
@status_window.refresh
for i in $game_party.battle_members
@status_window.draw_item($game_party.battle_members.index(i))
end
end
end
#==============================================================================
# ■ SideViewアクション設定
#------------------------------------------------------------------------------
# 　サイドビューバトル全般のセッティングやアクションを作成します
#==============================================================================
module N03
#--------------------------------------------------------------------------
# ● 全体のセッティング
#--------------------------------------------------------------------------
# アクター初期位置　一人目二人目三人目四人目
# X軸 Y軸 H軸 X軸 Y軸 H軸 X軸 Y軸 H軸 X軸 Y軸 H軸
ACTOR_POSITION = [[415,160, 0],[435,185, 0],[455,210, 0],[475,235, 0]]
# 行動終了時のウエイト(待ち時間・単位は1フレーム)
ACTION_END_WAIT = 8
# ターン終了時のウエイト(待ち時間・単位は1フレーム)
TURN_END_WAIT = 12
# 敵の不意打ち時にバックアタック(左右反転)を許可するならtrue しないならfalse
BACK_ATTACK = true
# 味方バトラーがダメージを受けた時、デフォルトのエフェクトを採用するならtrue
ACTOR_DAMAGE = false
# 敵バトラーがダメージを受けた時、デフォルトのエフェクトを採用するならtrue
ENEMY_DAMAGE = false
# 敵バトラーのX座標、回転計算、戦闘アニメを自動で反転させるならtrue
ENEMY_MIRROR = true
# コラプス禁止処理に使う、データベースの不死身ステートID
IMMORTAL_ID = 10
# バトルログ(戦闘の進行を実況表示するウィンドウ)を表示させるならtrue
# OFFにした場合、スキル名ウインドウが画面上部に表示されます
BATTLE_LOG = true
# スキル名ウインドウON時の、非表示にするスキルIDを配列に入れます
NO_DISPLAY_SKILL_ID = [1,2,3,4,5,6,7]
# ダメージ数字をPOPさせるならtrue
DAMAGE_POP = true
# ステート付加をPOPさせるならtrue
STATE_POP = true
# ダメージ数字画像のファイル名(Systemフォルダを参照します)
DAMAGE_PLUS = "damage_num+"
# 回復数字画像のファイル名(Systemフォルダを参照します)
DAMAGE_MINUS = "damage_num-"
# MPダメージ数字画像のファイル名(Systemフォルダを参照します)
DAMAGE_MP = "damage_mp"
# TPダメージ数字画像のファイル名(Systemフォルダを参照します)
DAMAGE_TP = "damage_tp"
# ダメージ数字の文字間隔を調整
DAMAGE_ADJUST = -4
# 戦闘カメラのフォーカス(移動先の焦点)を調整 [X軸, Y軸]
CAMERA_POSITION = [ 0, -40]
#--------------------------------------------------------------------------
# ● 戦闘背景セッティング背景の座標調整や拡大率を設定します
#--------------------------------------------------------------------------
# 床背景ﾌｧｲﾙ名…設定する床背景(Battlebacks1)画像ﾌｧｲﾙ名。
# "全Battlebacks1"は指定のないBattlebacks1画像を一括設定する項目です
# 壁背景ﾌｧｲﾙ名…設定する壁背景(Battlebacks2)画像ﾌｧｲﾙ名。
# "全Battlebacks2"は指定のないBattlebacks2画像を一括設定する項目です
# 座標調整…[X軸, Y軸]
# 拡大率……[横拡大率, 縦拡大率]
# ｼｪｲｸ可……シェイクアクションで揺れを許可するならtrue　しないならfalse
# ｽｲｯﾁﾄﾘｶﾞｰ…戦闘開始時に自動でONにするｹﾞｰﾑｽｲｯﾁ番号。ﾏｲﾅｽでｻｲﾄﾞﾋﾞｭｰ専用ｽｲｯﾁがON
# 背景とﾊﾞﾄﾙﾌﾟﾛｸﾞﾗﾑをセットで管理したい場合などに利用します
# スイッチ操作をしないなら0
FLOOR1_DATA = {
#――床背景ﾌｧｲﾙ名――― 座標調整拡大率ｼｪｲｸ可ｽｲｯﾁﾄﾘｶﾞｰ
"Sea_ex01" => [ [ 0, 120], [ 150, 150], false, -1],
"全Battlebacks1" => [ [ 0, 120], [ 150, 150], true, 0],
}
FLOOR2_DATA = {
#――壁背景ﾌｧｲﾙ名――― 座標調整拡大率ｼｪｲｸ可ｽｲｯﾁﾄﾘｶﾞｰ
"Ship_ex" => [ [ 0, 120], [ 150, 150], true, 0],
"全Battlebacks2" => [ [ 0, 120], [ 150, 150], true, 0],
}
#==============================================================================
# ■ アクション
#------------------------------------------------------------------------------
# 　バトラーが戦闘中に行う単発行動です。組み合わせてフルアクションにできます
#==============================================================================
# ここのアクション名やフルアクション名は、かぶらないようにしてください
ACTION = {
#--------------------------------------------------------------------------
# ● バトラーアニメ設定
#--------------------------------------------------------------------------
# デフォルトのキャラチップは一つの画像ファイルに複数のキャラが配置されています
# キャラチップを利用する場合、追加画像はキャラの画像配置に合うようにしてください
# 一人のキャラで一つの画像を用いる(ファイルの頭に$がある)場合は特に問題ありません
# ｲﾝﾃﾞｯｸｽ…利用するバトラー画像ﾌｧｲﾙの後ろに付くｲﾝﾃﾞｯｸｽ名。
# ｻｲﾄﾞﾋﾞｭｰのﾊﾞﾄﾗｰはｱｸﾀｰの場合だとｷｬﾗｸﾀｰﾌｧｲﾙ名を参照しますが
# ｲﾝﾃﾞｯｸｽが付くと、ｷｬﾗｸﾀｰﾌｧｲﾙ名+ｲﾝﾃﾞｯｸｽ名の画像ﾌｧｲﾙを参照します
# 例)Actor1のﾊﾞﾄﾗｰがｲﾝﾃﾞｯｸｽ"_1"のｱﾆﾒを実行する場合の参照ﾌｧｲﾙはActor1_1
# ｷｬﾗﾁｯﾌﾟを利用する場合のｱﾆﾒのｲﾝﾃﾞｯｸｽは""になります
# アクターはCharactersフォルダ、エネミーはBattlersフォルダに画像を入れます
#
# 縦ｾﾙ…画像ﾌｧｲﾙのセルの縦位置。上から0～3と続きます。数に制限はありません
# ｾﾙ数の設定はﾊﾞﾄﾗｰ設定で行ってください
# 横ｾﾙ…画像ﾌｧｲﾙのセルの横位置で、再生開始セル。左から0～3と続きます。
# ｱﾆﾒはこの横ｾﾙの左から右へと再生します。ｾﾙ数に制限はありません
# ﾊﾟﾀｰﾝ… 0:セル固定 1:片道　2:往復　3:片道ループ　4:往復ループ
# 速度…アニメの更新速度。数字が低いほど早く更新します
# Z軸…手前に表示するならプラス。通常は画面下ほど手前に表示されます
# ｳｴｲﾄ…アニメパターンが最後まで再生されてから次の行動に移るならtrue
# 影…影グラフィックを表示するならtrue、しない場合はfalse
# 武器…武器を表示する場合は武器アクション名を。しない場合は""
# 武器アクションはいくつでも同時追加可能で、追加分は配列の後ろに入れていきます
#―ｱｸｼｮﾝ名(待機系)― 判別ｲﾝﾃﾞｯｸｽ縦ｾﾙ横ｾﾙﾊﾟﾀｰﾝ速度 Z軸ｳｴｲﾄ影武器
"待機" => ["motion", "", 1, 0, 4, 12, 0, true, true, "" ],
"待機固定WT" => ["motion", "", 1, 1, 0, 12, 0, true, true, "" ],
"待機固定" => ["motion", "", 1, 1, 0, 12, 0,false, true, "" ],
"倒れ" => ["motion", "_1", 0, 0, 0, 12, 0, true,false, "" ],
"右向き" => ["motion", "", 2, 0, 4, 12, 0, true, true, "" ],
#―ｱｸｼｮﾝ名(移動系)― 判別ﾌｧｲﾙNo 縦ｾﾙ横ｾﾙﾊﾟﾀｰﾝ速度 Z軸ｳｴｲﾄ影武器
"左向き移動" => ["motion", "", 1, 0, 4, 6, 10, true, true, "" ],
"右向き移動" => ["motion", "", 2, 0, 4, 6, 10, true, true, "" ],
#―ｱｸｼｮﾝ名(ﾎﾟｰｽﾞ系)― 判別ﾌｧｲﾙNo 縦ｾﾙ横ｾﾙﾊﾟﾀｰﾝ速度 Z軸ｳｴｲﾄ影武器
#―ｱｸｼｮﾝ名(攻撃系)― 判別ﾌｧｲﾙNo 縦ｾﾙ横ｾﾙﾊﾟﾀｰﾝ速度 Z軸ｳｴｲﾄ影武器
"武器振りR" => ["motion", "", 1, 0, 1, 2, 200,false, true, "縦振り"],
"武器振りL" => ["motion", "", 1, 0, 1, 2, 200,false, true, "縦振りL"],
"武器振りLR" => ["motion", "", 1, 0, 1, 2, 200,false, true, "縦振り","縦振りL"],
"盾防御" => ["motion", "", 1, 0, 1, 2, 200,false, true, "盾"],
"武器拳突き" => ["motion", "", 1, 0, 1, 2, 200,false, true, "拳突き" ],
"武器突き" => ["motion", "", 1, 0, 1, 2, 200,false, true, "突き" ],
"武器掲げ" => ["motion", "", 1, 0, 1, 2, 200,false, true, "掲げ" ],
"弓撃ち" => ["motion", "", 1, 0, 1, 2, 200,false, true, "弓"],
#--------------------------------------------------------------------------
# ● バトラー移動エネミーのX軸移動は自動で逆計算になります
#--------------------------------------------------------------------------
# 目標…移動する目標座標の参照先。数値が正で現在地、負で初期位置を参照します([0=自分]は負が設定できないので-7にしてください)
# [0=自分] [1=ﾀｰｹﾞｯﾄ] [2=敵全] [3=味方全] [4=敵味方全] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ] [6=画面]
# X軸…対象から見たX座標
# Y軸…対象から見たY座標
# H軸…対象から見たH座標(地面からの高さ) nilにするとH軸を無視してXYのみの移動に
# 速度…1ﾌﾚｰﾑで移動するﾋﾟｸｾﾙ数。数値をﾏｲﾅｽにすると時間指定になり、移動完了までの総ﾌﾚｰﾑ数になります
# ｶｰﾌﾞ…移動時の軌道が正は上、負は下にカーブします。
# ｼﾞｬﾝﾌﾟ…ｼﾞｬﾝﾌﾟ放物線軌道。[ｼﾞｬﾝﾌﾟ開始から頂点までの軌道, 頂点から着地までの軌道]
# ｱﾆﾒ…その移動に利用するバトラーアニメのアクション名。
#――ｱｸｼｮﾝ名(ｼｽﾃﾑ系)―― 判別目標 X軸 Y軸 H軸速度ｶｰﾌﾞｼﾞｬﾝﾌﾟｱﾆﾒ
"戦闘前の味方配置" => ["move",-7, 180, 0, 0, 0, 0, [ 0, 0], "左向き移動"],
"退場" => ["move",-7, 180, 0, 0, 7, 0, [ 0, 0], "右向き移動"],
"逃走途中" => ["move",-7, 80, 0, 0, 7, 0, [ 0, 0], "右向き移動"],
"コマンド入力移動" => ["move",-7, -20, 0, nil,-10, 0, [ 0, 0], "左向き移動"],
"ダメージのけぞり" => ["move", 0, 20, 0, nil,-10, 0, [ 0, 0], ""],
"ダメージのけぞり大" => ["move", 0, 60, 0, nil,-10, 0, [ 0, 0], ""],
#――ｱｸｼｮﾝ名(ﾘｾｯﾄ系)―― 判別目標 X軸 Y軸 H軸速度ｶｰﾌﾞｼﾞｬﾝﾌﾟｱﾆﾒ
"座標リセット早" => ["move",-7, 0, 0, 0,-10, 0, [ 0, 0], "右向き移動"],
"座標リセット" => ["move",-7, 0, 0, 0,-20, 0, [ 0, 0], "右向き移動"],
"座標リセットカーブ" => ["move",-7, 0, 0, 0,-20, -2, [ 0, 0], "右向き移動"],
"座標リセット左向き" => ["move",-7, 0, 0, 0,-20, 0, [ 0, 0], "左向き移動"],
#――ｱｸｼｮﾝ名(自身系)―― 判別目標 X軸 Y軸 H軸速度ｶｰﾌﾞｼﾞｬﾝﾌﾟｱﾆﾒ
"一歩前移動" => ["move", 0, -20, 0, 0,-10, 0, [ 0, 0], "左向き移動"],
"一歩後移動" => ["move", 0, 20, 0, 0,-10, 0, [ 0, 0], "左向き移動"],
"一歩前ジャンプ" => ["move", 0, -30, 0, 0,-10, 0, [ 20,-20], "左向き移動"],
"一歩後ジャンプ" => ["move", 0, 30, 0, 0,-10, 0, [ 20,-20], "左向き移動"],
"勝利ジャンプ" => ["move", 0, 10, 0, 0,-25, 0, [ 30,-30], "待機固定"],
"勝利ジャンプ武器" => ["move", 0, 0, 0, 0,-15, 0, [ 20, 0], "武器掲げ"],
"勝利ジャンプ着地" => ["move",-7, 0, 0, 0,-10, 0, [ 0, 0], "武器振りR"],
"縦揺れ01" => ["move", 0, 0, 0, 20, -2, 0, [ 0, 0], ""],
"縦揺れ02" => ["move", 0, 0, 0, -20, -2, 0, [ 0, 0], ""],
#――ｱｸｼｮﾝ名(目標系)―― 判別目標 X軸 Y軸 H軸速度ｶｰﾌﾞｼﾞｬﾝﾌﾟｱﾆﾒ
"敵前移動" => ["move", 1, 30, 0, 0,-20, 0, [ 0, 0], "左向き移動"],
"敵後移動" => ["move", 1, -60, 0, 0,-20, 0, [ 0, 0], "左向き移動"],
"敵中移動早" => ["move", 1, 0, 0, 0,-10, 0, [ 0, 0], "左向き移動"],
"叩き付け前ジャンプ" => ["move",-1, 0, 0, 100,-20, 0, [ 40,-20], "武器掲げ"],
"叩き付け" => ["move",-1, 0, 0, 0,-10, 0, [ 0, 0], "武器振りR"],
#--------------------------------------------------------------------------
# ● 武器アクション　バトラーアニメや武器・アニメ飛ばしに利用するアクション
#--------------------------------------------------------------------------
# ﾀｲﾌﾟ…[0…アイコン利用]
# [1…独自画像(画像名はﾊﾞﾄﾗｰ設定の武器の項目で行います。参照先はCharactersフォルダ)]
# [2…アニメセル(※2003仕様。ﾊﾞﾄﾗｰと同じｾﾙ数でｱﾆﾒします。画像名はﾊﾞﾄﾗｰ設定の武器の項目で行います。参照先はCharactersフォルダ)]
# 移動…画像を動かす距離。[X軸, Y軸]
# 調整…微調整する画像の初期座標。[X軸, Y軸]
# 始度…動作前の最初の角度。半時計回りで0～360度。負が半時計回り
# 終度…動作後の角度
# 原点…画像の原点。[0…中心] [1…左上] [2…右上] [3…左下] [4…右下] [5…バトラーと同じ(画像下と縦半分)]
# 反転…trueにすると画像を反転して表示
# 拡大…[X軸拡大率, Y軸拡大率] 小数点でも受け付けます
# Z軸…画像をキャラより手前に表示するならtrue
# 逆手…盾画像、もしくは二刀流時の左(項目だと下)の武器画像を表示
# アイコンを利用しない場合、盾の画像はﾊﾞﾄﾗｰ設定の盾の項目で行います
# 更新…-1でバトラーアニメ更新と同期化。独立させる場合は [更新時間間隔, 更新パターン数, ループするか]
#
# ｲﾝﾃﾞｯｸｽ…武器画像は装備している武器(盾)に設定された画像ﾌｧｲﾙを参照しますが、
# ここでｲﾝﾃﾞｯｸｽを付けると、画像ﾌｧｲﾙ名+ｲﾝﾃﾞｯｸｽ名の画像を参照します
# 一つの武器で複数のﾊﾟﾀｰﾝがある画像を用いる場合に利用します
# 例) "縦振り"のｲﾝﾃﾞｯｸｽは"" => 画像ﾌｧｲﾙ名"IconSet"を参照
# 例) "縦振り2"のｲﾝﾃﾞｯｸｽは"_1" => 画像ﾌｧｲﾙ名"IconSet_1"を参照
# 参照ﾌｫﾙﾀﾞはｱｲｺﾝ利用の場合はSystemﾌｫﾙﾀﾞ、独自画像とｱﾆﾒｾﾙはCharactersフォルダです
#
# 画像…武器や盾に設定された画像ﾌｧｲﾙやｲﾝﾃﾞｯｸｽを無視して、武器画像を直接指定する場合は
# ここに画像ﾌｧｲﾙ名を入れます。画像はCharactersフォルダを参照します
#―ｱｸｼｮﾝ名― 判別ﾀｲﾌﾟ移動調整始度終度原点反転拡大 Z軸逆手更新ｲﾝﾃﾞｯｸｽ画像
"縦振り" => ["wp", 0,[ 6, 0],[ -4,-10], -45, 45, 4, false, [1,1], false, false, -1, "", ""],
"盾" => ["wp", 0,[ 0, 0],[ 12, 0], 0, 0, 4, false, [1,1], true, true, -1, "", ""],
"縦振りL" => ["wp", 0,[ 6, 0],[ 0, -8],-135, 45, 4, false, [1,1], true, true, -1, "", ""],
"拳突き" => ["wp", 0,[-20, 0],[ 5, 5], -45, -45, 4, false, [1,1], false, false, -1, "", ""],
"突き" => ["wp", 0,[-25, 0],[ 25,-10], 45, 45, 4, false, [1,1], false, false, -1, "", ""],
"掲げ" => ["wp", 0,[ 6,-4],[ -4,-10], 90, -45, 4, false, [1,1], false, false, -1, "", ""],
#―2003仕様― 判別ﾀｲﾌﾟ移動調整始度終度原点反転拡大 Z軸逆手更新ｲﾝﾃﾞｯｸｽ画像
"弓" => ["wp", 2,[ 0, 0],[ 0, 0], 0, 0, 5, false, [1,1], true, false, -1, "", ""],
# 武器飛ばし用判別ﾀｲﾌﾟ移動調整始度終度原点反転拡大 Z軸二刀更新ｲﾝﾃﾞｯｸｽ画像
"矢" => ["wp", 0,[ 0, 0],[ 0, 0], 0, 45, 0, false, [1,1], true, false,[2,6,false], "", "arrow01"],
"回転" => ["wp", 0,[ 0, 0],[ 0, 0], 0, 360, 0, false, [1,1], true, false,[1,8, true], "", ""],
#--------------------------------------------------------------------------
# ● 武器・アニメ飛ばし　武器や戦闘アニメを移動させます。飛び道具などに
#--------------------------------------------------------------------------
# ID…ﾃﾞｰﾀﾍﾞｰｽのｱﾆﾒID。0はｱﾆﾒ非表示。[移動させるｱﾆﾒID, ヒット時のｱﾆﾒID]
# 始…ｱﾆﾒ移動の開始位置。ﾏｲﾅｽにすると、複数ﾀｰｹﾞｯﾄでも一個のアニメだけ実行
# [0=自分] [1=ﾀｰｹﾞｯﾄ] [2=敵全] [3=味方全] [4=敵味方全] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ] [6=画面]
# 後…ｱﾆﾒ移動の終了位置。ﾏｲﾅｽにすると、複数ﾀｰｹﾞｯﾄでも一個のアニメだけ実行
# [0=自分] [1=ﾀｰｹﾞｯﾄ] [2=敵全] [3=味方全] [4=敵味方全] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ] [6=画面]
# 始調整…移動開始座標の微調整。[X軸, Y軸] エネミーはX軸が自動で逆計算に
# 後調整…移動終了座標の微調整。[X軸, Y軸] エネミーはX軸が自動で逆計算に
# 速度…1ﾌﾚｰﾑに移動するX軸ﾋﾟｸｾﾙ数。マイナスにすると時間扱いになり、距離によって速度が変わります
# ﾀｲﾌﾟ…移動後の処理。[0=消える(ミス時は自動で貫通に変化)] [1=貫通] [2=消える(ミス時も消える)]
# 軌道…移動の軌道。[開始から頂点までの軌道, 頂点から終了までの軌道]
# Z軸…アニメや武器をキャラより手前に表示するならtrue
# ｳｴｲﾄ…アクションが終わるまで次のアクションに移行しないならtrue [移動させるアニメのウエイト, ヒット時アニメのウエイト]
# ﾀﾞﾒｰｼﾞ…目標到達時にダメージ計算を適用するならtrue
# ﾎｰﾐﾝｸﾞ…移動するﾀｰｹﾞｯﾄに対してﾎｰﾐﾝｸﾞするならtrue。しないならfalse
# ｶﾒﾗ…カメラのズームに合わせてアニメを拡大縮小するならtrue
# ﾙｰﾌﾟ…移動させるアニメの再生が終わった時、最初にループさせるならtrue
# 反転不可…いかなる場合でもアニメを反転させないならtrue
# 武器…武器アクション名を入れます。利用しないなら""
#――ｱｸｼｮﾝ名―― 判別 ID 始後始調整後調整速度ﾀｲﾌﾟ軌道 Z軸ｳｴｲﾄﾀﾞﾒｰｼﾞﾎｰﾐﾝｸﾞｶﾒﾗﾙｰﾌﾟ反転不可武器
"矢発射WT" => ["m_a",[ 0,-1], 0, 1, [ 0, 0], [ 0, 0], 10, 2, [-3,-3], true, [ true, true], true, true, true, false, false, "矢"],
"矢発射" => ["m_a",[ 0,-1], 0, 1, [ 0, 0], [ 0, 0], 10, 2, [-3,-3], true, [false,false], true, true, true, false, false, "矢"],
"水鉄砲発射" => ["m_a",[69,69], 0, 1, [ 0, 0], [ 0, 0], 10, 0, [ 0, 0], true, [ true, true], true, true, true, true, false, ""],
"武器投げ開始" => ["m_a",[ 0,-1], 0, 1, [ 4,-6], [ 0, 0], 10, 2, [-3,-3], true, [ true,false], true, true, true, false, false, "回転"],
"武器投げ戻し" => ["m_a",[ 0, 0], 1, 0, [ 0, 0], [ 4,-6], 10, 0, [ 3, 3], true, [ true,false], false, true, true, false, false, "回転"],
#--------------------------------------------------------------------------
# ● 戦闘アニメ　データベースの戦闘アニメを表示します
#--------------------------------------------------------------------------
# ID…アニメID。-1で武器に設定されたアニメに -2は二刀流のもう片方の武器アニメに
# -3でスキルに設定されたアニメに
# 対象…[0=自分] [1=ﾀｰｹﾞｯﾄ] [2=敵全] [3=味方全] [4=敵味方全] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ]
# ﾎｰﾐﾝｸﾞ… 対象の座標移動にアニメが追尾するならtrue
# ｳｴｲﾄ…アニメ表示が終わるまで待つならtrue
# ﾀﾞﾒｰｼﾞ…ダメージ計算を適用するならtrue
# ｶﾒﾗ…カメラのズームに合わせてアニメを拡大縮小するならtrue
# 反転不可…いかなる場合でもアニメを反転させないならtrue
# 反転…アニメを反転させるならtrue
# Z軸…アニメをキャラより手前に表示するならtrue
#―ｱｸｼｮﾝ名(ﾀﾞﾒｰｼﾞ系)― 判別 ID 対象ﾎｰﾐﾝｸﾞｳｴｲﾄﾀﾞﾒｰｼﾞｶﾒﾗ反転不可反転 Z軸
"対象アニメ武器" => ["anime", -1, 1, false, false, true, true, false, false, true],
"対象アニメ武器WT" => ["anime", -1, 1, false, true, true, true, false, false, true],
"対象アニメ武器LWT" => ["anime", -2, 1, false, true, true, true, false, false, true],
"対象アニメ" => ["anime", -3, 1, false, false, true, true, false, false, true],
"対象アニメWT" => ["anime", -3, 1, false, true, true, true, false, false, true],
#――ｱｸｼｮﾝ名(自身系)―― 判別 ID 対象ﾎｰﾐﾝｸﾞｳｴｲﾄﾀﾞﾒｰｼﾞｶﾒﾗ反転不可反転 Z軸
"魔法詠唱中" => ["anime", 113, 0, false, true, false, true, false, false, true],
"特技待機中" => ["anime", 114, 0, false, true, false, true, false, false, true],
"魔法発動アニメ" => ["anime", 115, 0, false, true, false, true, false, false, false],
"特技発動アニメ" => ["anime", 116, 0, false, true, false, true, false, false, false],
#--------------------------------------------------------------------------
# ● カメラワーク画面のズームやスクロールを行います
#--------------------------------------------------------------------------
# 対象…移動やｽﾞｰﾑの対象
# [0=自分] [1=ﾀｰｹﾞｯﾄ] [2=敵全] [3=味方全] [4=敵味方全] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ] [6=画面]
# 調整座標…カメラ座標の最終地点微調整 [X軸(ﾌﾟﾗｽで画面→), Y軸(ﾌﾟﾗｽで画面↓)]
# 時間…カメラワークにかける時間
# ｽﾞｰﾑ…カメラのズーム率(%)。100でズームなし。
# ｳｴｲﾄ…カメラワークが終わるまで待つならtrue。待たないならfalse
#――ｱｸｼｮﾝ名―― 判別対象調整座標ｽﾞｰﾑ時間ｳｴｲﾄ
"カメラリセット"=> ["camera", 6, [ 0, 0], 100, 40, false],
"ズームイン" => ["camera", 6, [ 0, 100], 120, 40, false],
"ズームアウト" => ["camera", 6, [ 0, 0], 80, 40, false],
#--------------------------------------------------------------------------
# ● 画面のシェイク画面を揺らします。空中座標(H座標が0以上)のバトラーは揺れません
#--------------------------------------------------------------------------
# 方向…揺れる方向 [横,縦] 数値が大きいほど揺れ幅は大きくなります
# 速度…揺れの速度。小さいほど早く揺れます
# 時間…揺れの続く時間。揺れ幅は時間と共に弱まっていきます
# ｳｴｲﾄ…シェイクが終わるまで待つならtrue。待たないならfalse
#――ｱｸｼｮﾝ名―― 判別方向速度時間ｳｴｲﾄ
"シェイク小" => ["shake", [ 0, 4], 2, 16, false],
"シェイク中" => ["shake", [ 0, 6], 3, 30, false],
"シェイク大" => ["shake", [ 0,12], 3, 40, false],
#--------------------------------------------------------------------------
# ● 画面色調変更　背景やバトラーの色調を変更します
#--------------------------------------------------------------------------
# 対象…色調変更の対象
# [0=自分] [1=ﾀｰｹﾞｯﾄ] [2=敵全] [3=味方全] [4=敵味方全] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ]
# [6=背景] [7=自分+ﾀｰｹﾞｯﾄ] [8=自分以外] [9=自分+ﾀｰｹﾞｯﾄ以外] [10=全て]
# 色調レベル…[ R, G, B, ｱﾙﾌｧ(色の強さ), 変更時間, ※戻り]
# ※戻り…変更完了してから元の色に戻す時間。戻さないなら0
# ｳｴｲﾄ…色調変更が終わるまで待つならtrue。待たないならfalse
# 変更名判別対象 R, G, B,ｱﾙﾌｧ時間戻りｳｴｲﾄ
"色調初期化" => ["color", 10, [ 0, 0, 0, 0, 30, 0], false],
"ピンチ色調" => ["color", 0, [ 255, 50, 50, 100, 40, 40], false],
"毒色調" => ["color", 0, [ 170, 50, 255, 170, 30, 30], false],
"汎用状態異常色調" => ["color", 0, [ 255, 255, 50, 170, 40, 40], false],
"背景のみ暗転" => ["color", 6, [ 0, 0, 0, 255, 30, 0], false],
"自分とターゲット以外暗転" => ["color", 9, [ 0, 0, 0, 255, 30, 0], false],
#--------------------------------------------------------------------------
# ● トランジション　画面を固定した後に実行するトランジションです
#--------------------------------------------------------------------------
# 実行する前にアクション"画面固定"を実行し、画面を固定させてください
#
# 境界…境界の曖昧さ。値が大きいほど曖昧になります
# 時間…トランジションにかける時間。トランジション中はゲーム画面は固定されます
# ﾄﾗﾝｼﾞｼｮﾝﾌｧｲﾙ名…トランジション画像。Picturesフォルダに入れてください
#―――ｱｸｼｮﾝ名――― 判別境界時間ﾄﾗﾝｼﾞｼｮﾝﾌｧｲﾙ名
"サークル" => ["ts", 40, 60, "circle"],
#--------------------------------------------------------------------------
# ● 残像バトラーの移動に残像を残します
#--------------------------------------------------------------------------
# 数…残像数。0は表示中の残像を消します。あまり多いと負荷が高くなります
# 間隔…残像の表示間隔。小さいほど狭い。単位は1フレーム
# 処理…残像の後処理。trueはフルアクション終了時に消え、falseは消えずにずっと表示
# 透明度…残像の透明度
#――ｱｸｼｮﾝ名―― 判別数間隔処理透明度
"残像ON" => ["mirage", 4, 3, true, 160],
"残像OFF" => ["mirage", 0, 0, true, 0],
#--------------------------------------------------------------------------
# ● バトラー回転　画像を回転
#--------------------------------------------------------------------------
# 回転しているバトラーのフルアクションが終了すると、回転角度はリセットされます
# 回転中の画像転送元原点は中心になります。反転と違い、武器アクションは反映されません
#
# 時間…回転にかける時間。0で即座に反映されます
# 始度…回転開始時の角度。0～360度を指定。正が反時計周り、負が時計周り
# 終度…回転終了時の角度。0～360度を指定。上記ともにエネミーは逆計算になります
# ﾀｲﾌﾟ…回転終了後の処理。[0…回転ﾘｾｯﾄ] [1…終了角度のまま] [2…ﾙｰﾌﾟ]
#――ｱｸｼｮﾝ名―― 　判別時間始度終度ﾀｲﾌﾟ
"右1回転" => ["angle", 12, 0, -360, 0],
"左1回転" => ["angle", 12, 0, 360, 0],
#--------------------------------------------------------------------------
# ● バトラー拡大縮小　画像を拡大縮小
#--------------------------------------------------------------------------
# 拡大縮小しているバトラーのフルアクションが終了すると、拡大縮小はリセットされます
# 反転と違い、武器アクションは反映されません
#
# 時間…拡大縮小にかける時間。
# 開始ｻｲｽﾞ…拡大縮小開始時のｻｲｽﾞ。小数点で入れてください。[X軸(横), Y軸(縦)]
# 終了ｻｲｽﾞ…拡大縮小終了時のｻｲｽﾞ。小数点で入れてください。[X軸(横), Y軸(縦)]
# ﾀｲﾌﾟ…拡大縮小終了後の処理。[0…ｻｲｽﾞﾘｾｯﾄ] [1…終了ｻｲｽﾞのまま] [2…ﾙｰﾌﾟ]
#――ｱｸｼｮﾝ名―― 　判別時間開始ｻｲｽﾞ終了ｻｲｽﾞﾀｲﾌﾟ
"横縮み" => ["zoom", 12, [1.0, 1.0], [0.5, 1.0], 0],
"縦縮み" => ["zoom", 12, [1.0, 1.0], [1.0, 0.5], 0],
#--------------------------------------------------------------------------
# ● バトラー透明度操作　画像の透明度を変更
#--------------------------------------------------------------------------
# バトラーのフルアクションが終了すると、透明度操作はリセットされます
#
# 時間…透明度変更にかける時間。
# 開始…変更開始時の透明度。0が完全に消えた状態、255が完全に不透明な状態
# 終了…変更終了時の透明度
# 影…影も同じ透明度操作をするならtrue
# 武器…武器も同じ透明度操作をするならtrue
# ﾙｰﾌﾟ…透明度変更が終了した後、操作を自動で逆転させ続けるならtrue
# ｳｴｲﾄ…操作終了まで次のアクションに移行せず待つならtrue
#――ｱｸｼｮﾝ名―― 　判別時間開始終了影武器ﾙｰﾌﾟｳｴｲﾄ
"逃走透明" => ["opacity", 30, 255, 0, true, true, false, false],
"透明化" => ["opacity", 60, 255, 0, true, true, false, false],
"透明化WT" => ["opacity", 60, 255, 0, true, true, false, true],
"透明化解除" => ["opacity", 60, 0, 255, true, true, false, false],
"透明化解除WT" => ["opacity", 60, 0, 255, true, true, false, true],
#--------------------------------------------------------------------------
# ● ふきだしアニメ　イベントに使うふきだしアイコンを表示
#--------------------------------------------------------------------------
# 種類…ふきだしの種類(縦位置)を0～9で指定
# 速度…更新速度。セルは2コマ目から再生されます
# ｻｲｽﾞ…ふきだしのサイズ
# ふきだし名　　判別種類速度ｻｲｽﾞ
"状態異常/汎用" => ["balloon", 6, 10, 0.6],
"状態異常/ピンチ" => ["balloon", 5, 10, 0.6],
"状態異常/睡眠" => ["balloon", 9, 10, 0.6],
#--------------------------------------------------------------------------
# ● ピクチャの表示カットインなどに
#--------------------------------------------------------------------------
# 番号…使用するﾋﾟｸﾁｬの番号。ﾋﾟｸﾁｬを管理するための番号です。何枚でも表示できます
# フルアクションが終了すると自動で消去(Bitmap解放)されます
# 開始座標…移動開始位置。ﾋﾟｸﾁｬの左上を原点とします。[X軸, Y軸]
# 既にﾋﾟｸﾁｬがある場合、[]にすると開始座標はその場所になります
# 終了座標…移動終了位置。開始位置と同じ値にすると移動せず表示のみになります
# ﾌﾟﾚｰﾝ使用の場合、開始と終了を[]にすると移動速度を維持します
# 時間…移動時間。0でピクチャを消去します
# Z軸…ﾋﾟｸﾁｬのZ座標。100以上にするとウインドウより手前に表示されます
# 透明度…透明度設定。[開始時の透明度, 1フレームごとに加算される透明度]
# ﾌﾟﾚｰﾝ使用…ﾌﾟﾚｰﾝｸﾗｽ(画像がタイル状に並ぶ画像)を使用する場合の矩形。[X軸,Y軸]
# ﾌﾟﾚｰﾝを使用しない場合は[]
# BA反転…バックアタック時に画像反転とX座標移動を逆にするならtrue
# ﾌﾟﾚｰﾝ使用時の画像はtrueでも反転せず、X座標移動のみ逆になります
# ﾋﾟｸﾁｬﾌｧｲﾙ名…ピクチャフォルダ内のファイル名。
#―――ｱｸｼｮﾝ名――― 判別番号開始座標終了座標時間 Z軸透明度ﾌﾟﾚｰﾝ使用 BA反転ﾋﾟｸﾁｬﾌｧｲﾙ名
"カットインA1" => ["pic", 0, [-300, 8], [ 100, 8], 30, 90, [ 0, 10], [], true, "Actor4-1"],
"カットインA2" => ["pic", 0, [-300, 8], [ 100, 8], 30, 90, [ 0, 10], [], true, "Actor4-2"],
"カットインA3" => ["pic", 0, [-300, 8], [ 100, 8], 30, 90, [ 0, 10], [], true, "Actor5-2"],
"カットインA4" => ["pic", 0, [-300, 8], [ 100, 8], 30, 90, [ 0, 10], [], true, "Actor5-3"],
"カットイン終" => ["pic", 0, [], [ 600, 8], 30, 90, [255, 0], [], true, ""],
"カットイン背景始"=> ["pic", 1, [ 0, 8], [ 100, 8], 10, 80, [ 0, 10], [544,288], true, "cutin_back"],
"カットイン背景終"=> ["pic", 1, [], [], 10, 80, [255, -7], [544,288], true, ""],
"白フェードイン" => ["pic", 0, [ 0, 0], [ 0, 0], 50,500, [ 0, 6], [], false, "white"],
"白フェードアウト"=> ["pic", 0, [ 0, 0], [ 0, 0], 50,500, [255, -6], [], false, "white"],
#--------------------------------------------------------------------------
# ● ステート操作
#--------------------------------------------------------------------------
# 対象…[0=自分] [1=ﾀｰｹﾞｯﾄ] [2=敵全] [3=味方全] [4=敵味方全] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ]
# 拡張…上で設定した対象をさらに拡張します [0=拡張なし] [1=ﾗﾝﾀﾞﾑ1体] [2=自分を除く]
# 操作…ステートを付与するなら"+"　解除するなら"-"
# ｽﾃｰﾄID…操作するステートのIDをまとめて配列に入れます
# ステート付与名判別対象拡張操作ｽﾃｰﾄID
"戦闘不能付与" => ["sta", 0, 0, "+", [1]],
#--------------------------------------------------------------------------
# ● FPS(ゲーム全体のスピード)変更アクションの細部チェック用
#--------------------------------------------------------------------------
# ｹﾞｰﾑｽﾋﾟｰﾄﾞ…60がデフォルトで、低くなるほどスローになります。　
#――ｱｸｼｮﾝ名―― 判別ｹﾞｰﾑｽﾋﾟｰﾄﾞ
"スロー再生" => ["fps", 15],
"通常再生" => ["fps", 60],
#--------------------------------------------------------------------------
# ● バトラー画像変更バトラー画像の参照先ファイルを変更します
#--------------------------------------------------------------------------
# 維持…アクターの場合、戦闘後も変更を維持するならtrue
# ｲﾝﾃﾞｯｸｽ…アクターの場合、歩行グラのどの矩形かを設定します
# [0][1][2][3]
# [4][5][6][7]
#
# ﾌｧｲﾙ名…変更する画像ﾌｧｲﾙ名。アクターはCharactersフォルダ、
# エネミーはBattlersフォルダを参照します
# 顔ｸﾞﾗ…アクターの場合、戦闘後の顔ｸﾞﾗも変更するなら[顔ｸﾞﾗｲﾝﾃﾞｯｸｽ, ﾌｧｲﾙ名]
# 変更しないなら[]
#―――ｱｸｼｮﾝ名――― 判別維持ｲﾝﾃﾞｯｸｽﾌｧｲﾙ名顔ｸﾞﾗ
"オオカミに変身" => ["change", false, 6, "Animal", [0, "Actor4"]],
#--------------------------------------------------------------------------
# ● スキル派生アクションを中断し、別のスキルに派生させます
#--------------------------------------------------------------------------
# 習得…派生するスキルが未修得でも実行可能ならtrue
# ｺｽﾄ条件…派生するスキルのコストが足りなくても実行可能ならtrue
# ｽｷﾙID…派生するスキルID
#―――ｱｸｼｮﾝ名――― 判別習得ｺｽﾄ条件ｽｷﾙID
"多段攻撃に派生" => ["der", true, false, 1],
#--------------------------------------------------------------------------
# ● サウンドの演奏 BGM・BGS・SEを鳴らします
#--------------------------------------------------------------------------
# 種別…効果音は"se" BGMは"bgm" BGSは"bgs"
# ﾋﾟｯﾁ…ピッチ。50～150まで指定できます。100がデフォルトです
# 音量…ボリューム。50～150まで指定できます。100がデフォルトです
# ﾌｧｲﾙ名…再生するファイル名。""にするとBGM、BGSを変えずに各種設定可能。
#――ｱｸｼｮﾝ名―― 判別種別ﾋﾟｯﾁ音量ﾌｧｲﾙ名
"Bow1" => ["sound", "se", 100, 80, "Bow1"],
#--------------------------------------------------------------------------
# ● ムービーの再生 ogvファイルのムービーを再生します
#--------------------------------------------------------------------------
# ﾌｧｲﾙ名…再生するムービーファイル名。Moviesフォルダを参照します
#――ｱｸｼｮﾝ名―― 判別ﾌｧｲﾙ名
"死亡フラグムービー" => ["movie", "sample1"],
#--------------------------------------------------------------------------
# ● ゲームスイッチ(サイドビュー専用スイッチ)の操作
#--------------------------------------------------------------------------
# IDがプラスでゲームスイッチ、マイナスでサイドビュー専用スイッチの操作になります
#
# ON番号…ONにするスイッチIDをまとめて配列に入れます
# OFF番号…OFFにするスイッチIDをまとめて配列に入れます
#
#――ｱｸｼｮﾝ名―― 判別 ON番号 OFF番号
"スイッチNo1/ON" => ["switch", [ 1], []],
"背景を宇宙に変更"=> ["switch", [-4], []],
"背景宇宙を解除" => ["switch", [], [-4]],
"魔方陣ON" => ["switch", [-5], []],
"魔方陣OFF" => ["switch", [], [-5]],
#--------------------------------------------------------------------------
# ● ゲーム変数の操作
#--------------------------------------------------------------------------
# 変数No…何番の変数を操作するか
# 操作…[0=代入] [1=加算] [2=減算] [3=乗算] [4=除算] [5=剰余]
# ｵﾍﾟﾗﾝﾄﾞ…演算の対象となる数値を指定します。マイナスにすると、その数字の
# 絶対値の変数Noに格納されている数値が演算の対象となります
#
# ――ｱｸｼｮﾝ名―― 　　判別変数No 操作ｵﾍﾟﾗﾝﾄﾞ
"変数No1/+1" => ["variable", 1, 1, 1],
#--------------------------------------------------------------------------
# ● 条件分岐 (ゲームスイッチ) 条件を設定し、アクションを分岐させます
#--------------------------------------------------------------------------
# ｽｲｯﾁNo…何番のｽｲｯﾁを参照するか。ﾏｲﾅｽでｻｲﾄﾞﾋﾞｭｰ専用ｽｲｯﾁを操作します
# 条件…ONならtrue、OFFならfalse
# 分岐…条件を満たした場合の分岐処理。満たさない場合はその逆の処理がされます
# [0=次のｱｸｼｮﾝを実行] [1=次のｱｸｼｮﾝをｷｬﾝｾﾙ] [2=ﾌﾙｱｸｼｮﾝ終了]
#
#―――ｱｸｼｮﾝ名――― 判別ｽｲｯﾁNo 条件分岐
"スイッチNo1=ONで実行" => ["n_1", 1, true, 0],
#--------------------------------------------------------------------------
# ● 条件分岐 (ゲーム変数)
#--------------------------------------------------------------------------
# 変数No…何番の変数を参照するか
# 数値…条件となる数字を入れます。ﾏｲﾅｽでその絶対値の変数に格納された数値を参照します
# 条件…参照した変数が条件の数字と比べて…[0=同値] [1=少ない] [2=多い]
# 分岐…条件を満たした場合の分岐処理。満たさない場合はその逆の処理がされます
# [0=次のｱｸｼｮﾝを実行] [1=次のｱｸｼｮﾝをｷｬﾝｾﾙ] [2=ﾌﾙｱｸｼｮﾝ終了]
#
#―――ｱｸｼｮﾝ名――― 判別変数No 数値条件分岐
"変数No1=1で実行" => ["n_2", 1, 1, 0, 0],
#--------------------------------------------------------------------------
# ● 条件分岐 (ステート)
#--------------------------------------------------------------------------
# 対象…条件を参照する対象 [0=自分] [1=ﾀｰｹﾞｯﾄ] [2=敵全体] [3=味方全体] [4=敵味方全体] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ]
# ｽﾃｰﾄID…何番のステートを条件にするか
# 条件…[0=付加している] [1=付加していない]
# 人数…上の条件となる必要人数。条件対象がグループの場合、0でグループ全員の数になります
# 分岐…条件を満たした場合の分岐処理。満たさない場合はその逆の処理がされます
# [0=次のｱｸｼｮﾝを実行] [1=次のｱｸｼｮﾝをｷｬﾝｾﾙ] [2=ﾌﾙｱｸｼｮﾝ終了]
#
#―――ｱｸｼｮﾝ名――― 判別対象ｽﾃｰﾄID 条件人数分岐
"死亡確認" => ["n_3", 1, 1, 0, 1, 1],
#--------------------------------------------------------------------------
# ● 条件分岐 (スキル)
#--------------------------------------------------------------------------
# 対象…条件を参照する対象 [0=自分] [1=ﾀｰｹﾞｯﾄ] [2=敵全体] [3=味方全体] [4=敵味方全体] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ]
# ｽｷﾙID…何番のスキルを条件にするか
# 条件…[0=使える] [1=使えない]
# 人数…上の条件となる必要人数。条件対象がグループの場合、0でグループ全員の数になります
# 分岐…条件を満たした場合の分岐処理。満たさない場合はその逆の処理がされます
# [0=次のｱｸｼｮﾝを実行] [1=次のｱｸｼｮﾝをｷｬﾝｾﾙ] [2=ﾌﾙｱｸｼｮﾝ終了]
#
#―――ｱｸｼｮﾝ名――― 判別対象ｽｷﾙID 条件人数分岐
"強撃使用可限定" => ["n_4", 0, 80, 0, 1, 0],
#--------------------------------------------------------------------------
# ● 条件分岐 (パラメータ)
#--------------------------------------------------------------------------
# 対象…条件を参照する対象 [0=自分] [1=ﾀｰｹﾞｯﾄ] [2=敵全体] [3=味方全体] [4=敵味方全体] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ]
# 種別…どのパラメータを条件にするか
# [1=Lv] [2=最大HP] [3=最大MP] [4=HP] [5=MP] [6=TP] [7=攻撃力]
# [8=防御力] [9=魔法力] [10=魔法防御] [11=敏捷性] [12=運]
#
# 数値…条件となる数字を入れます。ﾏｲﾅｽで最大値からの割合％に(HP・MP・TP限定)
# 条件…参照したﾊﾟﾗﾒｰﾀが条件の数字と比べて…[0=同じ] [1=少ない] [2=多い]
# 人数…上の条件となる必要人数。条件対象がグループの場合、0でグループ全員の数になります
# 分岐…条件を満たした場合の分岐処理。満たさない場合はその逆の処理がされます
# [0=次のｱｸｼｮﾝを実行] [1=次のｱｸｼｮﾝをｷｬﾝｾﾙ] [2=ﾌﾙｱｸｼｮﾝ終了]
#
#―――ｱｸｼｮﾝ名――― 判別対象種別数値条件人数分岐
"HP50%以上で実行" => ["n_5", 0, 4, -50, 2, 1, 0],
#--------------------------------------------------------------------------
# ● 条件分岐 (装備)
#--------------------------------------------------------------------------
# 対象…条件を参照する対象 [0=自分] [1=ﾀｰｹﾞｯﾄ] [2=敵全体] [3=味方全体] [4=敵味方全体] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ]
# 種類…条件となる装備の種類 [0=武器] [1=防具]
# 装備ID…上の種類のアイテムID。IDは一括して配列[]に入れます。
# マイナスで武器(防具)タイプを参照します
# 条件…[0=装備している] [1=装備していない]
# 人数…上の条件となる必要人数。条件対象がグループの場合、0でグループ全員の数になります
# 分岐…条件を満たした場合の分岐処理。満たさない場合はその逆の処理がされます
# [0=次のｱｸｼｮﾝを実行] [1=次のｱｸｼｮﾝをｷｬﾝｾﾙ] [2=ﾌﾙｱｸｼｮﾝ終了]
#
#―――ｱｸｼｮﾝ名――― 判別対象種類 ID 条件人数分岐
"ハンドアクス限定" => ["n_6", 0, 0, [1], 0, 1, 0],
"拳限定" => ["n_6", 0, 0, [-2], 0, 1, 0],
"拳除外" => ["n_6", 0, 0, [-2], 0, 1, 1],
"弓限定" => ["n_6", 0, 0, [-6], 0, 1, 0],
"弓除外" => ["n_6", 0, 0, [-6], 0, 1, 1],
"拳弓除外" => ["n_6", 0, 0,[-2,-6], 0, 1, 1],
#--------------------------------------------------------------------------
# ● 条件分岐 (スクリプト)　
#--------------------------------------------------------------------------
# 分岐…条件を満たした場合の分岐処理。満たさない場合はその逆の処理がされます
# [0=次のｱｸｼｮﾝを実行] [1=次のｱｸｼｮﾝをｷｬﾝｾﾙ] [2=ﾌﾙｱｸｼｮﾝ終了]
# ｽｸﾘﾌﾟﾄ…trueかfalseを返すスクリプトを入れます
#
#―――ｱｸｼｮﾝ名――― 判別分岐ｽｸﾘﾌﾟﾄ
"50%の確率で実行" => ["n_7", 0, "rand(100) < 50"],
"アクター限定" => ["n_7", 0, "@battler.actor?"],
"アクターID1限定" => ["n_7", 0, "@battler.actor? && @battler.actor_id == 1"],
"アクターID2限定" => ["n_7", 0, "@battler.actor? && @battler.actor_id == 2"],
"アクターID6限定" => ["n_7", 0, "@battler.actor? && @battler.actor_id == 6"],
"アクターID7限定" => ["n_7", 0, "@battler.actor? && @battler.actor_id == 7"],
"エネミー限定" => ["n_7", 0, "[email protected]?"],
"エネミー中止" => ["n_7", 2, "[email protected]?"],
"二刀流限定" => ["n_7", 0, "@battler.dual_wield?"],
#--------------------------------------------------------------------------
# ● セカンドターゲット操作
#--------------------------------------------------------------------------
# セカンドターゲットとは、通常のターゲットとは別の独立したターゲット情報です
# 何も操作しない場合、通常ターゲットと同じ対象がセットされています
#
# 対象…[0=自分] [1=ターゲット] [2=敵全体] [3=味方全体] [4=敵味方全体] [5=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ]
#
# INDEX…対象をﾊﾟｰﾃｨのｲﾝﾃﾞｯｸｽ(並び順)で絞込みます INDEX = [ｲﾝﾃﾞｯｸｽ, 判別]
# ｲﾝﾃﾞｯｸｽ…ﾊﾟｰﾃｨのｲﾝﾃﾞｯｸｽ数値
# 判別…数値の条件 [0=絞込まない] [1=そのｲﾝﾃﾞｯｸｽが対象に] [2=そのｲﾝﾃﾞｯｸｽを排除]
#
# ID…対象をｱｸﾀｰ(ｴﾈﾐｰ)IDで絞込むならIDの数字を入れる。0で絞込まない
# ﾏｲﾅｽにするとその絶対値のIDが排除条件になります
#
# ｽﾃｰﾄ…対象を現在付加しているｽﾃｰﾄIDで絞込むならｽﾃｰﾄIDの数字を入れる。0で絞込まない
# ﾏｲﾅｽにすると付加していないことが条件になります
#
# ｽｷﾙ…対象を使用可能なｽｷﾙIDで絞込むならｽｷﾙIDの数字を入れる。0で絞込まない
# ﾏｲﾅｽにすると使用不可能が条件になります
#
# ﾊﾟﾗﾒｰﾀ…対象のパラメータを条件に絞込みますﾊﾟﾗﾒｰﾀ = [種別, 数値, 判別]
# 種別…[0=絞込まない] [1=Lv] [2=最大HP] [3=最大MP] [4=HP] [5=MP] [6=TP]
# [7=攻撃力] [8=防御力] [9=魔法力] [10=魔法防御] [11=敏捷性] [12=運]
# 数値…種別で決定した数値を入れる。ﾏｲﾅｽで最大値からの割合％に(HP・MP・TP限定)
# 判別…数値の条件 [0=同じ] [1=少ない] [2=多い]
#
# 装備…対象の装備物を条件に絞込みます。アクター限定装備 = [種類, ID]
# 種類…[0=武器] [1=防具]
# ID…装備種別の条件となるアイテムIDを配列[]に入れます。0で絞込まない
# マイナスで武器(防具)タイプを参照します
#
# 拡張…上で設定した対象をさらに拡張します [0=拡張なし] [1=ランダム1体] [2=自分を除く]
# 操作…[0=操作しない] [1=通常ﾀｰｹﾞｯﾄをｾｶﾝﾄﾞﾀｰｹﾞｯﾄに変更] [2=ｾｶﾝﾄﾞﾀｰｹﾞｯﾄ・通常ﾀｰｹﾞｯﾄを初期化]
#――ｱｸｼｮﾝ名―― 判別対象 INDEX ID ｽﾃｰﾄｽｷﾙﾊﾟﾗﾒｰﾀ装備拡張操作
"自分以外味方全員"=> ["s_t", 3, [ 0, 0], 0, 0, 0, [ 0, 0, 0], [ 0,[0]], 2, 0],
"全域化" => ["s_t", 4, [ 0, 0], 0, -1, 0, [ 0, 0, 0], [ 0,[0]], 0, 1],
#--------------------------------------------------------------------------
# ● スクリプトの操作
#--------------------------------------------------------------------------
# スクリプトを実行。サンプルのp = 1 の部分にevalで実行するスクリプトを入れます
#
#―――ｱｸｼｮﾝ名―――
"テストスクリプト" => ["p = 1 "],
#--------------------------------------------------------------------------
# ● その他　設定項目なしでフルアクションに入れます
#--------------------------------------------------------------------------
# 強制戦闘終了…戦闘を強制終了させます
# 画面固定…ｹﾞｰﾑ画面を固定させます。ﾄﾗﾝｼﾞｼｮﾝ前に入れます
# ダメージアニメ…スキルアニメを再生し、それが終わる直前にダメージをPOPさせます
# 反転…画像と武器アニメを反転します。再度反転させるかフルアクション終了で反転解除
# 武器消去…表示中の武器画像を消去します
# 武器消去解除…消去した武器画像を表示します
# 敵コラプス…崩御エフェクトを実行します。主に敵の戦闘不能に使用します
# コラプス禁止…対象のHPが0になった場合のコラプスを禁止します。連続攻撃開始時などに
# コラプス禁止解除…コラプス禁止を解除します。連続攻撃の終わりなどに。入れなくても行動終了時にコラプス許可になります
# 待機キャンセル…待機アクションを行わないようになります。戦闘イベントでの演出などに
# 待機キャンセル解除…待機キャンセルを解除し、待機アクションを行います
# 初期位置変更…元の座標(初期位置)を現在の座標に変更します
# 初期位置変更解除…初期位置変更で変更した座標を元に戻します
# 強制…この次にある行動をターゲットに強制させます(リアクション)
# 強制2…この次にある行動をセカンドターゲットに強制させます(リアクション)
# 次の行動者へ…戦闘行動が終了したとみなし、直後に次のキャラが行動開始します
# 個別開始…複数ﾀｰｹﾞｯﾄ攻撃を個別で処理する場合の、リピート行動開始の目印です
# 個別終了…複数ﾀｰｹﾞｯﾄ攻撃を個別で処理する場合の、リピート行動終了の目印です
# ループ開始…"ループ開始"と"ループ終了"の間のアクションを永遠に繰り返します
# ループ終了…"ループ開始""ループ終了"は主にコマンド入力後の待機アクションに利用します
#―――ｱｸｼｮﾝ名――― 判別
"強制戦闘終了" => ["battle_end"],
"画面固定" => ["graphics_freeze"],
"ダメージアニメ" => ["damage_anime"],
"反転" => ["mirror"],
"武器消去" => ["weapon_off"],
"武器消去解除" => ["weapon_on"],
"敵コラプス" => ["normal_collapse"],
"コラプス禁止" => ["no_collapse"],
"コラプス禁止解除" => ["collapse"],
"待機キャンセル" => ["non_motion"],
"待機キャンセル解除"=> ["non_motion_cancel"],
"初期位置変更" => ["change_base_position"],
"初期位置変更解除" => ["set_base_position"],
"強制" => ["force_action"],
"強制2" => ["force_action2"],
"次の行動者へ" => ["next_battler"],
"個別開始" => ["individual_start"],
"個別終了" => ["individual_end"],
"ループ開始" => ["loop_start"],
"ループ終了" => ["loop_end"],
#--------------------------------------------------------------------------
# ● ウエイト　次のアクションに行かずに待つ時間
#--------------------------------------------------------------------------
# アクションで数値のみの場合、それがそのままウエイト時間となります。
# (例) "20" …次のアクションに行かずに20フレーム待つ
#
# 数値をマイナスにするとランダムウエイトとなり、その数値の0～絶対値の間で
# ランダムにウエイト時間が決定されます。
# (例) "-20" …ランダムで0～20フレーム待つ
#--------------------------------------------------------------------------
# ● ショートカットコマンド
#--------------------------------------------------------------------------
# 通常は設定したアクション名をフルアクション配列に入れて行動を作りますが
# アクション設定せず直接コマンドを記述して、作業を短縮できるものがあります
# 頻繁に利用するものはこのｼｮｰﾄｶｯﾄを使うと登録ｱｸｼｮﾝが増えないのでお勧めです
#
# [戦闘アニメ]
# (例) "anime(20)" …データベース20番のアニメをターゲットに実行(ウエイトあり)
# (例) "anime(20,false)" …データベース20番のアニメをターゲットに実行(ウエイトなし)
# (例) "anime_me(20)" …データベース20番のアニメを自分に実行(ウエイトあり)
# (例) "anime_me(20,false)" …データベース20番のアニメを自分に実行(ウエイトなし)
#
# [ウエイトインデックスディレイ]　※ﾊﾟｰﾃｨｲﾝﾃﾞｯｸｽでウエイトにディレイを掛けます
# (例) "delay(12)"…ｲﾝﾃﾞｯｸｽ1番のｳｴｲﾄが0ﾌﾚｰﾑ　2番のｳｴｲﾄが12ﾌﾚｰﾑ 3番のｳｴｲﾄが24ﾌﾚｰﾑ…
#
# [効果音(SE)]
# (例) "se('Bow1')" …ファイル名がBow1のSEを鳴らします
# (例) "se('Bow1',50)" …ファイル名がBow1のSEをピッチ50で鳴らします
#
# [ターゲットへアクション(フルアクション)を強制]
# (例) "target('ダメージのけぞり')" …ﾀｰｹﾞｯﾄに"ダメージのけぞり"のｱｸｼｮﾝを強制します
# (例) "target2('被ダメージ')" …ｾｶﾝﾄﾞﾀｰｹﾞｯﾄに"被ダメージ"のﾌﾙｱｸｼｮﾝを強制します
}
#==============================================================================
# ■ フルアクション
#------------------------------------------------------------------------------
# 　アクションを組み合わせたもので、行動は左側から順番に行われます。
# フルアクションの中にフルアクションを入れることも可能で、アクションのパーツ化や
# 条件分岐の次にフルアクションを置く等の使い方が便利です
#==============================================================================
FULLACTION = {
# ―――待機系―――
"通常待機" => ["待機"],
"通常待機固定" => ["待機固定WT"],
"ピンチ待機" => ["状態異常/ピンチ","ピンチ色調","待機","待機"],
"防御待機" => ["待機固定WT"],
"毒待機" => ["状態異常/汎用","毒色調","待機","待機","エネミー限定","80"],
"睡眠待機" => ["状態異常/睡眠","エネミー限定","40","エネミー中止","倒れ","倒れ"],
"汎用状態異常待機"=> ["状態異常/汎用","汎用状態異常色調","待機","待機","エネミー限定","80"],
"様子見" => ["待機","60"],
"戦闘不能" => ["倒れ"],
# ――システム系――
"戦闘開始味方" => ["戦闘前の味方配置","delay(4)","座標リセット左向き"],
"味方退場" => ["退場"],
"逃走" => ["対象アニメ","カメラリセット","delay(4)","退場"],
"敵逃走" => ["対象アニメ","逃走透明","退場"],
"逃走失敗" => ["カメラリセット","delay(4)","逃走途中","一歩後移動","座標リセット左向き"],
"コマンド入力" => ["コマンド入力移動"],
"コマンド入力後" => ["座標リセット早"],
"コマンド後防御" => ["座標リセット早","ループ開始","待機固定WT","ループ終了"],
"コマンド後魔法" => ["座標リセット早","待機固定","ループ開始","魔法詠唱中","ループ終了"],
"コマンド後特技" => ["座標リセット早","待機固定","ループ開始","特技待機中","ループ終了"],
"防御" => ["対象アニメ","待機固定WT"],
"回避" => ["アクター限定","右1回転","一歩後ジャンプ","10","座標リセット左向き"],
"盾ガード" => ["se('Evasion2')","盾防御","60"],
"身代わり開始" => ["敵中移動早","初期位置変更"],
"身代わり終了" => ["初期位置変更解除","座標リセット左向き"],
"被身代わり開始" => ["一歩後移動","一歩後移動","待機固定WT"],
"被身代わり終了" => ["座標リセット左向き"],
"勝利ポーズ振り" => ["勝利ジャンプ武器","勝利ジャンプ着地","120"],
"勝利ポーズバク転"=> ["右1回転","勝利ジャンプ","拳限定","武器拳突き","拳除外","武器振りR","120"],
"閃き" => ["anime_me(119)","20"],
# ―リアクション系―
"被ダメージ" => ["ダメージのけぞり","座標リセット左向き"],
"被ダメージ大" => ["シェイク中","ダメージのけぞり大","座標リセット左向き"],
"透明" => ["透明化","ループ開始","120","ループ終了"],
"縦揺れ" => ["縦揺れ01","縦揺れ02","縦揺れ01","縦揺れ02","縦揺れ01","縦揺れ02"],
# ―ショートカット系(他のフルアクションから呼び出されるパーツ)―
"斬り" => ["武器振りR","対象アニメ武器","10"],
"拳" => ["武器拳突き","対象アニメ武器","10"],
"弓" => ["Bow1","弓撃ち","矢発射","9"],
"攻撃" => ["拳限定","拳","弓限定","弓","拳弓除外","斬り"],
"通常攻撃始め" => ["敵前移動","コラプス禁止","個別開始","二刀流限定","二刀左"],
"通常攻撃終わり" => ["死亡確認","対象アニメ武器WT","個別終了","コラプス禁止解除","次の行動者へ","座標リセットカーブ"],
"二刀左" => ["武器振りL","対象アニメ武器LWT"],
"特技発動" => ["一歩前移動","武器掲げ","特技発動アニメ"],
"魔法発動" => ["一歩前移動","武器掲げ","魔法発動アニメ"],
"カットイン" => ["カットイン背景始","カットイン分岐","70","カットイン終","カットイン背景終","20"],
"カットイン分岐" => ["アクターID1限定","カットインA1","アクターID2限定","カットインA2","アクターID6限定","カットインA3","アクターID7限定","カットインA4"],
"死亡フラグ動画" => ["白フェードイン","50","死亡フラグムービー","白フェードアウト","50"],
"背景を宇宙に" => ["ズームアウト","se('Blind',70)","背景のみ暗転","自分以外味方全員","強制2","透明","透明化","40","背景を宇宙に変更","色調初期化"],
"背景宇宙解除" => ["カメラリセット","背景のみ暗転","target2('透明化解除WT')","透明化解除","40","背景宇宙を解除","色調初期化"],
"魔方陣表示" => ["se('Blind',70)","画面固定","魔方陣ON","サークル"],
"魔方陣消去" => ["40","画面固定","魔方陣OFF","サークル"],
# ――通常攻撃系――
"通常攻撃" => ["通常攻撃始め","待機固定","通常攻撃終わり"],
"斬り攻撃" => ["通常攻撃始め","死亡確認","武器振りR","通常攻撃終わり"],
"拳攻撃" => ["通常攻撃始め","武器拳突き","通常攻撃終わり"],
"突き攻撃" => ["通常攻撃始め","武器突き","通常攻撃終わり"],
"弓攻撃" => ["一歩前移動","コラプス禁止","個別開始","Bow1","弓撃ち",
"矢発射WT","個別終了","コラプス禁止解除","座標リセット"],
# ――スキル系―――
"汎用スキル" => ["特技発動","武器振りR","ダメージアニメ","座標リセット"],
"汎用魔法" => ["魔法発動","武器振りR","ダメージアニメ","座標リセット"],
"水鉄砲" => ["特技発動","武器振りR","水鉄砲発射","座標リセット"],
"武器投げ" => ["特技発動","Bow1","武器振りR","6","待機固定","武器投げ開始","武器投げ戻し","座標リセット"],
"カットイン攻撃" => ["特技発動","カットイン","攻撃","座標リセット"],
"ムービー攻撃" => ["特技発動","待機固定","死亡フラグ動画","通常攻撃始め","武器振りR","通常攻撃終わり"],
"オオカミ変身" => ["特技発動","anime(110,false)","オオカミに変身","待機固定","120","座標リセット"],
"5回攻撃" => ["特技発動","コラプス禁止","弓除外","敵前移動","攻撃","攻撃","攻撃","攻撃","攻撃","コラプス禁止解除","座標リセット"],
"スキル派生" => ["武器投げ","多段攻撃に派生","斬り攻撃"],
"背景変更攻撃" => ["魔法発動","武器振りR","背景を宇宙に","ダメージアニメ","背景宇宙解除","座標リセット"],
"ピクチャ攻撃" => ["魔法発動","魔方陣表示","武器振りR","anime(80,false)","60","シェイク大","対象アニメ","魔方陣消去","座標リセット"],
"暗転攻撃" => ["特技発動","自分とターゲット以外暗転","se('Laser',150)",
"残像ON","敵前移動","anime(35,false)","敵後移動","対象アニメ",
"武器振りR","20","色調初期化","座標リセット","残像OFF"],
"空中攻撃" => ["特技発動","Bow1","一歩前ジャンプ","叩き付け前ジャンプ",
"待機固定","左1回転","10","anime(117,false)","叩き付け",
"対象アニメ","シェイク中","強制","縦揺れ","20",
"一歩後ジャンプ","座標リセット"],
# ――アイテム系―――
"アイテム使用" => ["敵前移動","待機固定","対象アニメWT","座標リセット左向き"],
}
#==============================================================================
# ■ バトルプログラム
#------------------------------------------------------------------------------
# 　バトルシーンの演出を時間管理します
# 　制御はゲームスイッチ・サイドビュー専用スイッチで行います
#==============================================================================
BATTLE_PROGRAM = {
#--------------------------------------------------------------------------
# ● スイッチの制御スイッチの時間操作で、演出をプログラムします
#--------------------------------------------------------------------------
# ｽｲｯﾁ…ﾌﾟﾛｸﾞﾗﾑ実行合図となるｹﾞｰﾑｽｲｯﾁ番号。ﾏｲﾅｽでｻｲﾄﾞﾋﾞｭｰ専用ｽｲｯﾁ番号になります
# OFFにすると、実行中のﾌﾟﾛｸﾞﾗﾑは中止されます
# ｻｲﾄﾞﾋﾞｭｰ専用ｽｲｯﾁは戦闘終了時に初期化(全てOFFに)されます
# イベントで戦闘前にｻｲﾄﾞﾋﾞｭｰ専用ｽｲｯﾁを操作する場合、イベントスクリプトで
# $sv_camera.switches[1] = true と入れてください
# (1は操作するｽｲｯﾁ番号、ONにするならtrue OFFにするならfalse)
#
# ON番号…ONにするするｹﾞｰﾑｽｲｯﾁ番号。ﾏｲﾅｽでｻｲﾄﾞﾋﾞｭｰ専用ｽｲｯﾁ番号になります
# 番号は一括して配列に入れます。
# 例…[1,2,-5] ｹﾞｰﾑｽｲｯﾁ1番2番とｻｲﾄﾞﾋﾞｭｰ専用ｽｲｯﾁ5番がON
#
# OFF番号…OFFにするするｹﾞｰﾑｽｲｯﾁ番号。ﾏｲﾅｽでｻｲﾄﾞﾋﾞｭｰ専用ｽｲｯﾁ番号になります
# 操作しない場合は[]と入れます
#
# 時間…上のスイッチ操作を実行するまでの時間(単位は1フレーム)
# 例えば100とした場合、ﾌﾟﾛｸﾞﾗﾑ開始から100ﾌﾚｰﾑ後にｽｲｯﾁ操作が実行されます
# [参考値] 30秒…1800　1分…3600　5分…18000 10分…36000　1時間…216000
#
# ﾗﾝﾀﾞﾑ幅…時間に加算されるランダム幅。単位は1フレーム
# 例えば時間300、ﾗﾝﾀﾞﾑ幅300だと最終的に300～600フレームの時間になります
#――ﾌﾟﾛｸﾞﾗﾑ名―― 判別ｽｲｯﾁ ON番号 OFF番号時間ﾗﾝﾀﾞﾑ幅
"背景を砦に" => ["switch", -1, [-2], [], 1200, 0],
"背景を海に" => ["switch", -2, [-3], [], 2400, 0],
#--------------------------------------------------------------------------
# ● SE/BGM/BGSの演奏
#--------------------------------------------------------------------------
# ｽｲｯﾁ…実行合図となるｹﾞｰﾑｽｲｯﾁ番号。ﾏｲﾅｽはｻｲﾄﾞﾋﾞｭｰ専用ｽｲｯﾁ。
#
# 種別…SEの操作なら"se" BGMの操作なら"bgm" BGSの操作なら"bgs"
#
# ﾋﾟｯﾁ…ピッチ。50～150まで指定できます。100がデフォルトです
# 音量…ボリューム。50～150まで指定できます。100がデフォルトです
# ﾌｧｲﾙ名…再生するファイル名。""にするとBGM、BGSを変えずに各種設定可能。
#――ﾌﾟﾛｸﾞﾗﾑ名―― 判別ｽｲｯﾁ種別ﾋﾟｯﾁ音量ﾌｧｲﾙ名
"潮騒" => ["sound", -1, "bgs", 100, 80, "Sea"],
#--------------------------------------------------------------------------
# ● 背景の制御画像変更や自動スクロールを行います
#--------------------------------------------------------------------------
# ｽｲｯﾁ…実行合図となるｽｲｯﾁ番号
#
# No.…操作する背景のナンバー。1が床背景、2が壁背景(遠景)になります
#
# ｽｸﾛｰﾙ速度…背景の移動する速度。[X軸, Y軸]
# 単位は100フレームあたりに移動するピクセル数になります
# 高速で移動させる場合は、1000単位の数値が目安です
#
# BA反転…バックアタック時に背景のX座標スクロールを逆にするならtrue 画像は反転しません
#
# 画像…背景画像を変更する場合、ﾌｧｲﾙ名を入れます。変更しない場合は""
# 床背景はBattlebacks1フォルダ、壁背景はBattlebacks2フォルダから参照します
# 変更する背景設定は、変更前のものを引き継ぎます
#
# 繋ぎ画像…背景ｽｸﾛｰﾙ時、背景変更を自然に見せるための繋ぎ画像ﾌｧｲﾙ名
# ｽｸﾛｰﾙ途中で背景変更が行われた場合、ｽｸﾛｰﾙが終わってから変更が行われます
# 性質上、斜めスクロールには対応していません
#
# 割込み…この背景が表示されている時に別の背景制御が割り込んできた場合、
# 割込みを許可するならtrue(繋ぎ画像表示中はｽｸﾛｰﾙなしの背景だけが割込みます)
# 割込みを許可しないならfalse(別の背景制御は保留され、この背景が消えた時に変更されます)
#――ﾌﾟﾛｸﾞﾗﾑ名―― 判別ｽｲｯﾁ No. ｽｸﾛｰﾙ速度 BA反転画像繋ぎ画像割込み
"遠景右移動" => ["scroll", -1, 1, [ 40, 0], true, "", "", true],
"海背景3に変更" => ["scroll", -2, 1, [ 120, 0], true, "Sea_ex03", "Sea_ex02", true],
"海背景4に変更" => ["scroll", -3, 1, [ 40, 0], true, "Sea_ex01", "Sea_ex04", true],
"宇宙に変更1" => ["scroll", -4, 1, [ 0, 0], true, "DarkSpace", "", false],
"宇宙に変更2" => ["scroll", -4, 2, [ 0, 0], true, "DarkSpace", "", false],
#--------------------------------------------------------------------------
# ● 周期ピクチャ　周期的にタイル状のピクチャを操作します。風や巨大魔方陣などに
#--------------------------------------------------------------------------
# ｽｲｯﾁ…実行合図となるｹﾞｰﾑｽｲｯﾁ番号
# No.…操作するﾋﾟｸﾁｬの番号。ﾋﾟｸﾁｬは何枚も表示できます
# 移動速度…100フレームあたりに移動するﾋﾟｸﾁｬの速度。[X軸, Y軸] 0で背景ｽｸﾛｰﾙと同期化
# 期間…このプログラムを行う期間。単位は1フレーム。0にすると時間無制限でループ
#
# 透明操作…ﾋﾟｸﾁｬの透明度操作。[開始透明度, 100ﾌﾚｰﾑあたりに加算する透明度]
# 透明度が255になると開始透明度まで戻り、それを繰り返します
# Z軸…ﾋﾟｸﾁｬのZ座標。100以上にするとウインドウより手前に表示されます
# ｼｪｲｸ許可…シェイクアクションの揺れと連動するならtrue
# BA反転…バックアタック時にピクチャのX座標移動を逆にするならtrue 画像は反転しません
# ﾌｧｲﾙ名…ﾋﾟｸﾁｬのﾌｧｲﾙ名。Picturesフォルダを参照します
#――ﾌﾟﾛｸﾞﾗﾑ名―― 判別ｽｲｯﾁ No. 移動速度期間透明操作 Z軸ｼｪｲｸ許可 BA反転ﾌｧｲﾙ名
"風" => ["kpic", -1, 0, [ 500, 0], 0, [ 255, 0], 90, false, true, "back_wind"],
"魔方陣" => ["kpic", -5, 1, [ 0, 0], 0, [ 255, 0], 90, true, true, "magic_square01"],
#--------------------------------------------------------------------------
# ● 周期SE　周期的に効果音を鳴らします。雷鳴や潮騒などに
#--------------------------------------------------------------------------
# ｽｲｯﾁ…実行合図となるｹﾞｰﾑｽｲｯﾁ番号
# 周期…効果音を鳴らす周期。単位は1フレーム。この間隔で効果音が定期的に鳴ります
# ﾗﾝﾀﾞﾑ幅…周期に加算されるランダム幅。単位は1フレーム
#
# ﾋﾟｯﾁ…ピッチ。50～150まで指定できます。100がデフォルトです
# 音量…ボリューム。50～150まで指定できます。100がデフォルトです
# 開始実行…ﾌﾟﾛｸﾞﾗﾑ実行直後に周期を待たず鳴らすならtrue
# ﾌｧｲﾙ名…再生するファイル名。
#――ﾌﾟﾛｸﾞﾗﾑ名―― 判別ｽｲｯﾁ周期ﾗﾝﾀﾞﾑ幅ﾋﾟｯﾁ音量開始実行ﾌｧｲﾙ名
"カモメ" => ["keep_se", -1, 400, 100, 150, 60, false, "Crow"],
"カモメ2" => ["keep_se", -1, 300, 200, 140, 45, true, "Crow"],
#--------------------------------------------------------------------------
# ● 周期シェイク　周期的に画面を揺らします
#--------------------------------------------------------------------------
# ｽｲｯﾁ…実行合図となるｹﾞｰﾑｽｲｯﾁ番号。これがONになることで開始されます
# 周期…画面を揺らす周期。単位は1フレーム
# ﾗﾝﾀﾞﾑ幅…周期に加算されるランダム幅。単位は1フレーム
#
# 方向…揺れる方向 [横,縦] 数値が大きいほど揺れも大きくなります
# 速度…揺れの速度。小さいほど早く揺れます
# 時間…揺れの続く時間。揺れ幅は時間と共に少しずつ弱まっていきます
# 開始実行…ﾌﾟﾛｸﾞﾗﾑ実行直後に周期を待たず揺らすならtrue
#――ﾌﾟﾛｸﾞﾗﾑ名―― 判別ｽｲｯﾁ周期ﾗﾝﾀﾞﾑ幅方向速度時間開始実行
"船の揺れ" => ["keep_sk", -1, 130, 0, [ 0, 4], 80, 120, true],
#--------------------------------------------------------------------------
# ● 周期色調変更　周期的に画面の色調を変更します
#--------------------------------------------------------------------------
# ｽｲｯﾁ…実行合図となるｹﾞｰﾑｽｲｯﾁ番号。これがONになることで開始されます
# 周期…色調変更させる周期。単位は1フレーム
# ﾗﾝﾀﾞﾑ幅…周期に加算されるランダム幅。単位は1フレーム
#
# 対象…色調変更の対象 [0=背景] [1=敵全] [2=味方全] [3=敵味方全] [4=全て]
# 色調レベル…[ R, G, B, ｱﾙﾌｧ(色の強さ), 変更時間, ※戻り]
# ※戻り…変更完了してから元の色に戻す時間。戻さないなら0
# 開始実行…ﾌﾟﾛｸﾞﾗﾑ実行直後に周期を待たず色調変更するならtrue
#――ﾌﾟﾛｸﾞﾗﾑ名―― 判別ｽｲｯﾁ周期ﾗﾝﾀﾞﾑ幅対象 R, G, B, ｱﾙﾌｧ時間戻り開始実行
"雷光" => ["keep_c", 0, 300, 100, 4, [ 255, 255, 255, 255, 8, 8], true],
"エマージェンシー" => ["keep_c", 0, 150, 0, 4, [ 255, 0, 0, 100, 40, 40], true],
}
#==============================================================================
# ■ カメラ設定
#------------------------------------------------------------------------------
# 　アクションとは別にバトルシーンの各ポイントでカメラワークを行います
# 　アクション名でカメラが動くため、名前は変えないようにしてください
#==============================================================================
BATTLE_CAMERA = {
#--------------------------------------------------------------------------
# ● カメラワーク画面のズームやスクロールを行います
#--------------------------------------------------------------------------
# 対象…移動やｽﾞｰﾑの対象 [2=敵全] [3=味方全] [4=敵味方全] [6=画面]
# 調整座標…カメラ座標の最終地点微調整 [X軸(ﾌﾟﾗｽで画面→), Y軸(ﾌﾟﾗｽで画面↓)]
# 時間…カメラワークにかける時間
# ｽﾞｰﾑ…カメラのズーム率(%)。100でズームなし。
#――ｱｸｼｮﾝ名―― 判別対象調整座標ｽﾞｰﾑ時間
"ターン開始前" => ["camera", 6, [ 40, 0], 95, 40],
"ターン開始後" => ["camera", 6, [ 0, 0], 100, 40],
"戦闘終了時" => ["camera", 6, [ 100, 0], 100, 50],
}
end
#==============================================================================
# ■ SideViewバトラー設定
#------------------------------------------------------------------------------
# 　アクション設定で作ったアクションをバトラーに貼り付けたり
# 　バトラーに関する設定を行います
#==============================================================================
class SideView
#--------------------------------------------------------------------------
# ● バトラーアニメ画像の横・縦セル数 = [ 横, 縦]　アニメさせない場合は[1, 1]
#--------------------------------------------------------------------------
def max_pattern
# バトラーIDで分岐
case id
when 1 # 1番のアクター
return [ 3, 4]
when -1 # 1番のエネミー(エネミーはIDをマイナスにすることで指定します)
return [ 1, 1]
else # 上のID以外を一括で設定
return [ 3, 4] if id > 0 # 全アクター(IDがプラス)
return [ 1, 1] if id < 0 # 全エネミー(IDがマイナス)
end
# 以降の設定でID分岐させる場合はこの記述を参考にしてください
end
#--------------------------------------------------------------------------
# ● 影画像ファイル名画像はCharactersフォルダに入れてください falseで影なし
#--------------------------------------------------------------------------
def shadow
return "shadow01" if id > 0 # 全アクター
return false if id < 0 # 全エネミー
end
#--------------------------------------------------------------------------
# ● バトラー画像反転設定　初期状態でバトラー画像を反転させるならtrue
#--------------------------------------------------------------------------
def graphic_mirror_flag
return false if id > 0 # 全アクター
return true if id < 0 # 全エネミー
end
#--------------------------------------------------------------------------
# ● バトラー画像参照先固定　ﾊﾞﾄﾗｰｱﾆﾒ設定のｲﾝﾃﾞｯｸｽ参照を必ず""にするならtrue
#--------------------------------------------------------------------------
def graphic_fix
return false if id > 0 # 全アクター
return true if id < 0 # 全エネミー
end
#--------------------------------------------------------------------------
# ● 通常待機
#--------------------------------------------------------------------------
def normal
return "通常待機" if id > 0 # 全アクター
return "待機固定WT" if id < 0 # 全エネミー
# フルアクションではなくアクションだけを貼り付けることもできます
end
#--------------------------------------------------------------------------
# ● ピンチ待機 HPが1/4以下の状態で行う待機アクション
#--------------------------------------------------------------------------
def pinch
return "ピンチ待機" if id > 0 # 全アクター
end
#--------------------------------------------------------------------------
# ● ステートアクション複数重なった場合、表示優先度の高いステートが優先されます
#--------------------------------------------------------------------------
def state(state_id)
# ステートIDで分岐
case state_id
when 1
return "戦闘不能" if id > 0 # 全アクター
return "敵コラプス" if id < 0 # 全エネミー
when 2
return "毒待機"
when 6
return "睡眠待機"
when 3,4,5,7,8
return "汎用状態異常待機"
when 9
return "防御待機"
end
end
#--------------------------------------------------------------------------
# ● 戦闘開始アクション
#--------------------------------------------------------------------------
def first_action
return "戦闘開始味方" if id > 0 # 全アクター
return "待機固定WT" if id < 0 # 全エネミー
end
#--------------------------------------------------------------------------
# ● 勝利アクション
#--------------------------------------------------------------------------
def win
case id
when 2,7,10 # 2・7・10番のアクター
return "勝利ポーズバク転"
else # 上記以外
return "勝利ポーズ振り"
end
end
#--------------------------------------------------------------------------
# ● 戦闘退場アクションパーティの入れ替えが行われた際の退場アクション
#--------------------------------------------------------------------------
def remove_action
return "味方退場"
end
#--------------------------------------------------------------------------
# ● 逃走アクション
#--------------------------------------------------------------------------
def escape
return "逃走" if id > 0 # 全アクター
return "敵逃走" if id < 0 # 全エネミー
end
#--------------------------------------------------------------------------
# ● 逃走失敗アクション
#--------------------------------------------------------------------------
def escape_ng
return "逃走失敗"
end
#--------------------------------------------------------------------------
# ● コマンド入力前動作
#--------------------------------------------------------------------------
def command_b
return "コマンド入力"
end
#--------------------------------------------------------------------------
# ● コマンド入力後動作
#--------------------------------------------------------------------------
def command_a
# 選択したスキルIDで分岐
case skill_id
when 2
return "コマンド後防御"
end
# 選択したスキルタイプで指定
case skill_type
when 1 # 特技
return "コマンド後特技"
when 2 # 魔法
return "コマンド後魔法"
end
# 上の指定以外
return "コマンド入力後"
end
#--------------------------------------------------------------------------
# ● 被ダメージアクション　
#--------------------------------------------------------------------------
def damage(attacker)
# 受けた攻撃がクリティカルの場合
if critical?
return "被ダメージ大"
# 回復の場合
elsif recovery?
# アクションを取らせたくない時はreturnのみを記述します
return
end
# 受けたスキルIDで分岐
case damage_skill_id
when 1 # スキル1番の場合
return "被ダメージ"
when 136 # 特定のスキルにダメージアクションを取らせたくない時はここでreturnのみを記述します
return
end
# 受けたアイテムIDで指定(回復の場合は既にアクションが決定されています)
case damage_item_id
when 1 # アイテム1番の場合
return
else
# 上のアイテムID以外
if damage_item_id != 0
return
end
end
# ダメージが0の場合 (強化・弱体化魔法や防御、エネミーの逃走など)
if damage_zero?
return
end
# 上の設定に当てはまらない場合
return "被ダメージ"
end
#--------------------------------------------------------------------------
# ● 回避動作被ダメージアクションと同じ分岐が可能です
#--------------------------------------------------------------------------
def evasion(attacker)
return "盾ガード" if shield? # 盾を装備している場合
return "回避"
end
#--------------------------------------------------------------------------
# ● 相手の攻撃ミス時の動作被ダメージアクションと同じ分岐が可能です
#--------------------------------------------------------------------------
def miss(attacker)
return "盾ガード" if shield? # 盾を装備している場合
return "回避"
end
#--------------------------------------------------------------------------
# ● 武器アクション通常攻撃のアクションを装備武器で指定します
# エネミーは下のエネミー武器設定で持たせることができます
#--------------------------------------------------------------------------
def weapon_action
# 武器IDで指定
case weapon_id
when 0 # 武器0番の場合(素手)
return "通常攻撃"
when 1 # 武器1番の場合
return "斬り攻撃"
end
# 武器タイプで指定
case weapon_type
when 1 # 武器タイプ1番の場合
return "斬り攻撃"
when 4,5,7,8,9 # 複数まとめて指定する場合
return "斬り攻撃"
when 2
return "拳攻撃"
when 3
return "突き攻撃"
when 6
return "弓攻撃"
end
end
#--------------------------------------------------------------------------
# ● エネミー右手武器エネミーにも装備武器をID指定します
#--------------------------------------------------------------------------
def enemy_weapon1_id
case id
when -1 # 1番のエネミー(エネミーはIDをマイナスにすることで分岐させます)
return 0 # 武器IDを指定。0番は素手扱いです
else
return 0
end
end
#--------------------------------------------------------------------------
# ● エネミー左手武器エネミーにも二刀装備武器をID指定します
#--------------------------------------------------------------------------
def enemy_weapon2_id
return 0
end
#--------------------------------------------------------------------------
# ● エネミー盾エネミーにも盾をID指定します左手武器より優先されます
#--------------------------------------------------------------------------
def enemy_shield_id
return 0
end
#--------------------------------------------------------------------------
# ● 武器グラフィック指定　
#--------------------------------------------------------------------------
# 武器アクションのタイプ設定で [1:独自画像] [2:2003仕様]を選択した際の
# 参照先の画像をここで指定します
# return "001-Weapon01" ←対応する武器グラフィックのファイル名を入れてください
# 武器グラフィックはCharactersフォルダに入れてください
# 特定の武器を非表示にしたい場合は空の画像を用意して、それを指定します
def weapon_graphic(weapon_id, weapon_type)
# 武器IDで指定
case weapon_id
when 1 # 武器1番の画像ファイル名
return ""
end
# 武器タイプで指定
case weapon_type
when 6 # 武器タイプ6番の画像ファイル名
return "bow01"
end
end
#--------------------------------------------------------------------------
# ● 盾グラフィック指定　
#--------------------------------------------------------------------------
# 武器アクションのタイプ設定で [1:独自画像] [2:2003仕様]を選択し、さらに
# 武器アクションの逆手設定をtrueにした場合の参照先の盾画像をここで指定します
#
# return "001-Shield01" ←対応する盾グラフィックのファイル名を入れてください
# 盾グラフィックはCharactersフォルダに入れてください
def shield_graphic(weapon_id, shield_type)
# 防具IDで指定
case shield_id
when 41 # 防具41番(バックラー)の画像ファイル名
return ""
end
# 防具タイプで指定
case shield_type
when 5 # 防具タイプ5番(小型盾)の画像ファイル名
return ""
end
end
#--------------------------------------------------------------------------
# ● スキルアクション
#--------------------------------------------------------------------------
def skill_action
# スキルIDで指定
case skill_id
when 1 # スキル1番は通常攻撃なので、上の武器アクションを実行します
return weapon_action
when 2 # スキル2番は防御
return "防御"
when 3,4,5 # スキル3/4/5番は連続攻撃
return weapon_action
when 6 # スキル6番はエネミー逃走
return escape
when 7 # スキル7番は様子を見る
return "様子見"
when 128
return "水鉄砲"
when 129
return "武器投げ"
when 130
return "5回攻撃"
when 131
return "カットイン攻撃"
when 132
return "ムービー攻撃"
when 133
return "オオカミ変身"
when 134
return "スキル派生"
when 135
return "暗転攻撃"
when 136
return "空中攻撃"
end
# スキル名で指定(データベースでIDを移動させても大丈夫なのでお勧めです)
case skill_name
when "背景変更サンプル"
return "背景変更攻撃"
when "ピクチャ攻撃サンプル"
return "ピクチャ攻撃"
end
# スキルタイプで指定
case skill_type
when 1 # 特技
return "汎用スキル"
when 2 # 魔法
return "汎用魔法"
end
# 上記以外
return "汎用スキル"
end
#--------------------------------------------------------------------------
# ● アイテムアクション
#--------------------------------------------------------------------------
def item_action
case item_id # アイテムIDで指定
when 1
return "アイテム使用"
else
return "アイテム使用"
end
end
#--------------------------------------------------------------------------
# ● カウンタースキルID　カウンター時のスキルIDを指定します
#--------------------------------------------------------------------------
# ※データベースで設定された複数回攻撃は反映されません
def counter_skill_id
return 1
end
#--------------------------------------------------------------------------
# ● 魔法反射アニメID　魔法反射時のアニメIDを指定します
#--------------------------------------------------------------------------
def reflection_anime_id
return 118
end
#--------------------------------------------------------------------------
# ● 身代わり開始アクション
#--------------------------------------------------------------------------
def substitute_start_action
return "身代わり開始"
end
#--------------------------------------------------------------------------
# ● 身代わり終了アクション
#--------------------------------------------------------------------------
def substitute_end_action
return "身代わり終了"
end
#--------------------------------------------------------------------------
# ● 身代わりされた側のアクション開始
#--------------------------------------------------------------------------
def substitute_receiver_start_action
return "被身代わり開始"
end
#--------------------------------------------------------------------------
# ● 身代わりされた側のアクション終了
#--------------------------------------------------------------------------
def substitute_receiver_end_action
return "被身代わり終了"
end
#--------------------------------------------------------------------------
# ● エネミーのレベル条件分岐などに利用するためのもので、パラメータは反映されません
#--------------------------------------------------------------------------
def level
case id
when -1 # 1番のエネミー
return 0
end
return 0
end
end
#==============================================================================
# ■ Sideview
#------------------------------------------------------------------------------
# 　サイドビューバトラーを管理するクラスです。
#==============================================================================
class SideView
#--------------------------------------------------------------------------
# ● 公開インスタンス変数　
#--------------------------------------------------------------------------
attr_accessor :x # 画面X座標
attr_accessor :y # 画面Y座標
attr_accessor :z # 画面Z座標
attr_accessor :h # 高さ座標
attr_accessor :j # ジャンプ座標
attr_accessor :c # カーブ座標
attr_accessor :ox # 横原点
attr_accessor :oy # 縦原点
attr_accessor :oy_adjust # 縦原点補正
attr_accessor :angle # 回転角度
attr_accessor :zoom_x # 横の拡大率
attr_accessor :zoom_y # 縦の拡大率
attr_accessor :pattern_w # セル横位置（矩形内）
attr_accessor :pattern_h # セル縦位置（矩形内）
attr_accessor :sx # セル横位置（画像全体）
attr_accessor :sy # セル縦位置（画像全体）
attr_accessor :pattern_type # セル更新タイプ
attr_accessor :pattern_time # セル更新間隔
attr_accessor :graphic_name # バトラー画像ファイル名
attr_accessor :graphic_file_index # バトラー画像ファイル名インデックス
attr_accessor :graphic_index # バトラー画像インデックス
attr_accessor :cw # セル横矩形
attr_accessor :ch # セル縦矩形
attr_accessor :shadow_visible # 影表示
attr_accessor :weapon_visible # 武器表示
attr_accessor :wait # 次の動作待ち時間
attr_accessor :weapon_index # 表示中の武器画像インデックス配列
attr_accessor :weapon_end # 武器アニメ終了フラグ
attr_accessor :force_action # 強制アクション
attr_accessor :target_battler # ターゲットバトラー情報
attr_accessor :second_targets # セカンドターゲット情報
attr_accessor :m_a_targets # アニメ飛ばしターゲット情報
attr_accessor :individual_targets # 個別処理ターゲットバトラー情報
attr_accessor :effect_data # エフェクトデータ
attr_accessor :anime_id # アニメID配列
attr_accessor :anime_move_id # 飛ばしアニメID配列
attr_accessor :mirror # 反転フラグ
attr_accessor :opacity # 透明度
attr_accessor :opacity_data # 透明度操作情報
attr_accessor :set_damage # バトルシーンでのダメージ処理
attr_accessor :m_a_data # アニメ飛ばし情報
attr_accessor :m_a_starter # アニメ飛ばし開始ターゲット情報
attr_accessor :action_end # バトルシーンでの行動終了
attr_accessor :damage_anime_data # ダメージ戦闘アニメのデータ
attr_accessor :anime_no_mirror # 戦闘アニメの反転禁止フラグ
attr_accessor :anime_horming # 戦闘アニメのホーミングフラグ
attr_accessor :anime_camera_zoom # 戦闘アニメがカメラに合わせて拡大縮小するか
attr_accessor :anime_plus_z # 戦闘アニメZ座標補正
attr_accessor :derivation_skill_id # スキル派生ID
attr_accessor :immortal # 不死身フラグ
attr_accessor :mirage # 残像データ
attr_accessor :balloon_data # ふきだしデータ
attr_accessor :timing # 別バトラーからのタイミングデータ
attr_accessor :timing_targets # タイミングデータを渡す別バトラー
attr_accessor :color_set # 色調変更データ
attr_accessor :color # 色調データ
attr_accessor :change_up # 画像変更フラグ
attr_accessor :hit # 被攻撃回数
attr_accessor :add_state # 何度も付加ステートの表示を防ぐフラグ
attr_accessor :counter_id # カウンター時のスキルID
attr_accessor :reflection_id # 魔法反射時のアニメID
attr_accessor :result_damage # ターン終了時のHP変動データ
attr_accessor :active # 行動権
attr_accessor :base_x # 初期位置 X座標
attr_accessor :base_y # 初期位置 Y座標
attr_accessor :base_h # 初期位置高さ座標
attr_accessor :max_pattern_w # セルの横分割数
attr_accessor :max_pattern_h # セルの縦分割数
attr_reader :collapse # コラプスフラグ
attr_reader :picture # ピクチャ表示フラグ
#--------------------------------------------------------------------------
# ● オブジェクト初期化
#--------------------------------------------------------------------------
def initialize(battler)
@battler = battler
reset
end
#--------------------------------------------------------------------------
# ● 初期化
#--------------------------------------------------------------------------
def reset
@x = 0
@y = 0
@z = 0
@h = 0
@j = 0
@c = 0
@jump = []
@curve = []
@ox = 0
@oy = 0
@oy_adjust = 0
@z_plus = 0
@move_time = 0
@angle = 0
@angle_time = 0
@zoom_x = 1
@zoom_y = 1
@zoom_time = 0
@pattern_w = 0
@pattern_h = 0
@sx = 0
@sy = 0
@pattern_type = 0
@pattern_time = 0
@pattern_rest_time = 0
@graphic_name = ""
@graphic_file_index = ""
@graphic_index = 0
@cw = 0
@ch = 0
@shadow_visible = false
@weapon_visible = true
@wait = 0
@weapon_index = []
@weapon_end = true
@full_action = []
@action = []
@force_action = ""
@target_battler = []
@second_targets = []
@individual_targets = []
@m_a_targets = []
@effect_data = []
@anime_id = []
@anime_move_id = []
@opacity = 255
@opacity_data = []
@set_damage = false
@m_a_data = []
@m_a_starter = []
@action_end = false
@damage_anime_data = []
@anime_no_mirror = false
@anime_horming = false
@anime_camera_zoom = false
@anime_plus_z = true
@derivation_skill_id = 0
@immortal = false
@mirage = []
@play_data = []
@balloon_data = []
@picture = false
@timing = []
@timing_targets = []
@color_set = []
@color = []
@change_up = false
@non_motion = false
@graphics_change = false
@hit = 0
@add_state = []
@collapse = false
@counter_id = 0
@reflection_id = 0
@result_damage = [0,0]
@active = false
@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
start_action(first_action) if first_action_flag && @battler.movable?
if first_action_flag && [email protected]?
stand_by_action
@action_data = N03::ACTION[@action]
next_action
end
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 set_data
return if @battler == nil
if @battler.actor?
@graphic_name = @battler.character_name
@graphic_index = @battler.character_index
else
@graphic_name = @battler.battler_name
@graphic_index = 0
end
@max_pattern_w = max_pattern[0]
@max_pattern_h = max_pattern[1]
end
#--------------------------------------------------------------------------
# ● グラフィックデータ取得
#--------------------------------------------------------------------------
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
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_target(target = nil)
@target_battler = target
@target_battler = [@battler] if target == nil
@second_targets = @target_battler
end
#--------------------------------------------------------------------------
# ● アクション開始
#--------------------------------------------------------------------------
def start_action(kind = nil)
# ウェイト中の場合キャンセル
return @wait -= 1 if @wait > 0 && kind == nil
action_setup if kind != nil
set_action(kind)
@action = kind if @action == nil
# 行動配列が無い場合は行動終了処理へ移行
action_terminate if @action == nil
# 次のアクション決定
@action_data = N03::ACTION[@action]
next_action
end
#--------------------------------------------------------------------------
# ● 行動パラメータの初期化
#--------------------------------------------------------------------------
def action_setup
@set_damage = false
@action_end = false
@balloon_data = []
@loop_act = []
angle_reset
zoom_reset
opacity_reset
@curve = []
@c = 0
convert_jump
end
#--------------------------------------------------------------------------
# ● 行動終了処理
#--------------------------------------------------------------------------
def action_terminate
@mirage = [] if @mirage_end
mirroring_reset
@picture = false
@individual_targets = []
action_setup
# 待機アクションへ移行
stand_by_action if !@non_motion
# 戦闘行動のアクティブ権を終了
next_battler
end
#--------------------------------------------------------------------------
# ● 新しいアクション内容の決定
#--------------------------------------------------------------------------
def set_action(kind = nil)
full_act = N03::FULLACTION[kind]
@full_action = full_act.dup if full_act != nil
@action = @full_action.shift
# 参照したアクションがフルアクションであれば全体のアクションを統合
full_act2 = N03::FULLACTION[@action]
@full_action = full_act2.dup + @full_action if full_act2 != nil
end
#--------------------------------------------------------------------------
# ● 次のアクションへ
#--------------------------------------------------------------------------
def next_action
@wait = 0
# ショートカット確認
eval(@action) if @action != nil && @action_data == nil && N03::FULLACTION[@action] == nil
# ウエイト設定
@wait = @action.to_i if @wait == 0 && @action_data == nil
@wait = rand(@wait.abs + 1) if @wait < 0
# アクション開始
action_play
end
#--------------------------------------------------------------------------
# ● 待機アクションへ移行
#--------------------------------------------------------------------------
def stand_by_action
# 通常待機に
stand_by_act = normal
# HPが1/4でピンチアクションに
stand_by_act = pinch if @battler.hp <= @battler.mhp / 4
# ステートチェック
stand_by_act = state(@battler.states[0].id) if @battler.states[0] != nil && state(@battler.states[0].id) != nil
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 BattleManager.process_abort if action == "battle_end"
# 画面固定の場合
return Graphics.freeze if action == "graphics_freeze"
# ダメージアニメの場合
return damage_anime if action == "damage_anime"
# 武器消去の場合
return @weapon_visible = false if action == "weapon_off"
# 武器消去解除の場合
return @weapon_visible = true if action == "weapon_on"
# 待機キャンセルの場合
return @non_motion = true if action == "non_motion"
# 待機キャンセル解除の場合
return @non_motion = false if action == "non_motion_cancel"
# 初期位置変更の場合
return change_base_position if action == "change_base_position"
# 初期位置変更解除の場合
return set_base_position(false) if action == "set_base_position"
# 強制アクションの場合
return force_act if action == "force_action"
# 強制アクションの場合 (セカンドターゲット)
return force_act2 if action == "force_action2"
# 個別開始の場合
return individual_start if action == "individual_start"
# 個別終了の場合
return individual_end if action == "individual_end"
# ループ開始の場合
return loop_start if action == "loop_start"
# ループ終了の場合
return loop_end if action == "loop_end"
# 自分のみ更新の場合
return only_action_on if action == "only_action_on"
# 自分のみ更新解除の場合
return only_action_off if action == "only_action_off"
# 次の行動者へ移行の場合
return next_battler if action == "next_battler"
# 画像変更フラグの場合
return set_change if action == "set_change"
# スクリプト操作の場合
return eval(@action_data[0])
end
#--------------------------------------------------------------------------
# ● バトラー反転実行
#--------------------------------------------------------------------------
def mirroring
@mirror = !@mirror
end
#--------------------------------------------------------------------------
# ● 反転初期化
#--------------------------------------------------------------------------
def mirroring_reset
@mirror = false
mirroring if [email protected]? && N03::ENEMY_MIRROR
mirroring if $sv_camera.mirror
end
#--------------------------------------------------------------------------
# ● 残像実行
#--------------------------------------------------------------------------
def mirage_set
@mirage = @action_data.dup
@mirage_end = @mirage[3]
@mirage = [] if @mirage[1] == 0
end
#--------------------------------------------------------------------------
# ● 回転実行
#--------------------------------------------------------------------------
def angling(data = @action_data)
@angle_data = data.dup
@oy = @ch / 2
@oy_adjust = @ch * 50
@angle_time = data[1]
start_angle = data[2] * N03.mirror_num(@mirror)
end_angle = data[3] * N03.mirror_num(@mirror)
# 時間が0以下なら即座に最終角度へ
@angle_time = 1 if @angle_time <= 0
# 回転時間から1フレームあたりの角度を出す
@angling = (end_angle - start_angle) / @angle_time
# 割り切れない余りを初期角度に
@angle = (end_angle - start_angle) % @angle_time + start_angle
end
#--------------------------------------------------------------------------
# ● 回転初期化
#--------------------------------------------------------------------------
def angle_reset
@oy = @ch
@angle = @angle_time = @oy_adjust = 0
end
#--------------------------------------------------------------------------
# ● 拡大縮小実行
#--------------------------------------------------------------------------
def zooming(data = @action_data)
@zoom_data = data.dup
@zoom_time = data[1]
start_zoom_x = data[2][0]
start_zoom_y = data[2][1]
end_zoom_x = data[3][0]
end_zoom_y = data[3][1]
# 時間が0以下なら即座に最終サイズへ
@zoom_time = 1 if @zoom_time <= 0
# 拡大縮小時間から1フレームあたりの拡大縮小率を出す
@zooming_x = (end_zoom_x - start_zoom_x) / @zoom_time
@zooming_y = (end_zoom_y - start_zoom_y) / @zoom_time
# 開始サイズに
@zoom_x = start_zoom_x
@zoom_y = start_zoom_y
end
#--------------------------------------------------------------------------
# ● 拡大縮小初期化
#--------------------------------------------------------------------------
def zoom_reset
@zoom_x = @zoom_y = 1
@zoom_time = 0
end
#--------------------------------------------------------------------------
# ● バトラー透明度操作
#--------------------------------------------------------------------------
def set_opacity
data = @action_data.dup
@opacity = data[2]
opacity_move = (data[3] - data[2])/ data[1]
@opacity_data = [data[1], data[1], opacity_move, data[4], data[5], data[6]]
@wait = data[1] if data[7]
@wait *= 2 if data[6] && data[7]
end
#--------------------------------------------------------------------------
# ● 透明度操作初期化
#--------------------------------------------------------------------------
def opacity_reset
@opacity = 255
@opacity = 0 if @battler.hidden?
@opacity_data = []
end
#--------------------------------------------------------------------------
# ● バトラーアニメ実行
#--------------------------------------------------------------------------
def battler_anime(anime_data = nil)
anime_data = @action_data.dup if anime_data == nil
@graphic_file_index = anime_data[1] if !graphic_fix
@pattern_h = anime_data[2]
@pattern_w = anime_data[3]
@pattern_h = 0 if @max_pattern_w == 1
@pattern_w = 0 if @max_pattern_h == 1
@pattern_type = anime_data[4]
@pattern_time = anime_data[5]
@pattern_rest_time = anime_data[5]
@pattern_count = 0
@pattern_kind = 1
@pattern_kind = -1 if @pattern_type < 0
@pattern_kind = 0 if @pattern_type == 0
@sx = (@graphic_index % 4 * @max_pattern_w + @pattern_w) * @cw
@sy = (@graphic_index / 4 * @max_pattern_h + @pattern_h) * @ch
@z_plus = anime_data[6]
@wait = set_anime_wait if anime_data[7]
@shadow_visible = anime_data[8]
weapon_anime(anime_data)
end
#--------------------------------------------------------------------------
# ● アニメウエイト計算
#--------------------------------------------------------------------------
def set_anime_wait
if @pattern_type > 0
pattern_time_a = @max_pattern_w - @pattern_w.abs
elsif @pattern_type < 0
pattern_time_a = @pattern_w.abs + 1
else
return @pattern_time if @pattern_type == 0
end
case @pattern_type
when 1,-1, 3,-3
return pattern_time_a * @pattern_time
when 2,-2, 4,-4
return pattern_time_a * @pattern_time + (@max_pattern_w - 2) * @pattern_time
end
end
#--------------------------------------------------------------------------
# ● 移動実行
#--------------------------------------------------------------------------
def move
@move_targets = N03.get_targets(@action_data[1].abs, @battler)
return if @move_targets == []
@move_targets = [@battler] if @action_data[1].abs == 7
@move_x = @action_data[2] * 100 * N03.mirror_num(@mirror)
@move_y = @action_data[3] * 100
@move_h = @action_data[4] * 100 if @action_data[4] != nil
@move_h = nil if @action_data[4] == nil
battler_anime(N03::ACTION[@action_data[8]].dup) if N03::ACTION[@action_data[8]] != nil
@horming_move = true
@horming_move = false if @action_data[1] < 0 or @action_data[1].abs == 7
target_position_set
target_position = [@target_x, @target_y, @target_z]
distanse_move = @action_data[5] > 0
@move_time = N03.distanse_calculation(@action_data[5].abs, target_position, [@x, @y, @z], distanse_move)
@wait = @move_time
curve
jump
@move_time = 1 if @move_time == 0
@horming_move = false if @move_targets.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 = data[1]
target.animation_mirror = data[8]
target.sv.anime_horming = data[3]
target.sv.anime_camera_zoom = data[6]
target.sv.anime_no_mirror = data[7]
target.sv.anime_plus_z = data[9]
end
#--------------------------------------------------------------------------
# ● 戦闘アニメ拡張データの初期化
#--------------------------------------------------------------------------
def reset_anime_data
@anime_no_mirror = false
@anime_horming = false
@anime_camera_zoom = false
@timing_targets = []
@anime_plus_z = true
end
#--------------------------------------------------------------------------
# ● カメラワーク
#--------------------------------------------------------------------------
def camera
data = @action_data.dup
N03.camera(@battler, data)
@wait = data[4] if data[5]
end
#--------------------------------------------------------------------------
# ● 画面のシェイク
#--------------------------------------------------------------------------
def shake
data = @action_data.dup
$sv_camera.shake(data[1], data[2], data[3])
@wait = data[3] if data[4]
end
#--------------------------------------------------------------------------
# ● 画面色調変更
#--------------------------------------------------------------------------
def color_effect
case @action_data[1]
when 0,1,2,3,4,5
targets = N03.get_targets(@action_data[1], @battler)
when 6
screen = true
when 7
targets = [@battler] + @target_battler
when 8
screen = true
targets = $game_troop.members + $game_party.battle_members - [@battler]
when 9
screen = true
targets = $game_troop.members + $game_party.battle_members - [@battler] - @target_battler
when 10
screen = true
targets = $game_troop.members + $game_party.battle_members
end
return if screen == nil && targets == []
for target in targets do target.sv.color_set = @action_data[2] end if targets
@wait = @action_data[2][4] if @action_data[3]
return if !screen
$sv_camera.color_set[1] = @action_data[2]
$sv_camera.color_set[2] = @action_data[2]
end
#--------------------------------------------------------------------------
# ● トランジション
#--------------------------------------------------------------------------
def transition
$sv_camera.perform_transition(@action_data)
end
#--------------------------------------------------------------------------
# ● ふきだしアニメ表示
#--------------------------------------------------------------------------
def balloon_anime
@balloon_data = @action_data.dup
end
#--------------------------------------------------------------------------
# ● ピクチャ表示
#--------------------------------------------------------------------------
def picture_set
@picture = true
set_effect_data
end
#--------------------------------------------------------------------------
# ● ステート操作
#--------------------------------------------------------------------------
def state_set
targets = N03.get_targets(@action_data[1], @battler)
return if targets == []
case @action_data[2]
when 1 ; targets = [targets[rand(targets.size)]]
when 2 ; targets -= @battler if targets.include?(@battler)
end
for target in targets
for id in @action_data[4]
target.add_state(id) if @action_data[3] == "+"
target.remove_state(id) if @action_data[3] == "-"
end
end
end
#--------------------------------------------------------------------------
# ● FPS変更
#--------------------------------------------------------------------------
def fps
Graphics.frame_rate = @action_data[1]
start_action
end
#--------------------------------------------------------------------------
# ● バトラー画像変更の場合
#--------------------------------------------------------------------------
def graphics_change
@graphics_change = true
return @battler.graphics_change(@action_data[3]) if [email protected]?
@pre_change_data = [@battler.character_name, @battler.character_index, @battler.face_name, @battler.face_index] if !@action_data[1]
if @action_data[4] == []
face_name = @battler.face_name
face_index = @battler.face_index
else
face_name = @action_data[4][1]
face_index = @action_data[4][0]
end
@battler.set_graphic(@action_data[3], @action_data[2], face_name, face_index)
end
#--------------------------------------------------------------------------
# ● スキル派生
#--------------------------------------------------------------------------
def derivating_skill
# 未修得スキルは派生不可なら
return if !@action_data[1] && [email protected]_learn?($data_skills[@action_data[3]])
# コスト不足は派生不可なら
return if !@action_data[2] && [email protected]_cost_payable?($data_skills[@action_data[3]])
# 派生
@derivation_skill_id = @action_data[3]
# 以降のアクションをキャンセル
@full_action = []
end
#--------------------------------------------------------------------------
# ● BGM/BGS/SE演奏
#--------------------------------------------------------------------------
def sound
pitch = @action_data[2]
vol = @action_data[3]
name = @action_data[4]
case @action_data[1]
when "se"
Audio.se_play("Audio/SE/" + name, vol, pitch)
when "bgm"
# 名前指定のない場合、現在のBGMを変えないように
name = RPG::BGM.last.name if @action_data[4] == ""
Audio.bgm_play("Audio/BGM/" + name, vol, pitch)
when "bgs"
name = RPG::BGS.last.name if @action_data[4] == ""
Audio.bgs_play("Audio/BGS/" + name, vol, pitch)
end
end
#--------------------------------------------------------------------------
# ● ムービーの再生
#--------------------------------------------------------------------------
def movie
Graphics.play_movie('Movies/' + @action_data[1])
end
#--------------------------------------------------------------------------
# ● ゲームスイッチ操作
#--------------------------------------------------------------------------
def switches
for id in @action_data[1]
$game_switches[id] = true if id > 0
$sv_camera.switches[id.abs] = true if id < 0
end
for id in @action_data[2]
$game_switches[id] = false if id > 0
$sv_camera.switches[id.abs] = false if id < 0
end
$sv_camera.program_check
end
#--------------------------------------------------------------------------
# ● ゲーム変数操作
#--------------------------------------------------------------------------
def variable
# オペランドチェック
operand = @action_data[3]
operand = $game_variables[@action_data[3].abs] if @action_data[3] < 0
# 変数操作で分岐
case @action_data[2]
when 0 ; $game_variables[@action_data[1]] = operand # 代入
when 1 ; $game_variables[@action_data[1]] += operand # 加算
when 2 ; $game_variables[@action_data[1]] -= operand # 減算
when 3 ; $game_variables[@action_data[1]] *= operand # 乗算
when 4 ; $game_variables[@action_data[1]] /= operand # 除算
when 5 ; $game_variables[@action_data[1]] %= operand # 剰余
end
end
#--------------------------------------------------------------------------
# ● 条件分岐 (ゲームスイッチ)
#--------------------------------------------------------------------------
def nece_1
judgment = $game_switches[@action_data[1]] == @action_data[2] if @action_data[1] > 0
judgment = $sv_camera.switches[@action_data[1].abs] == @action_data[2] if @action_data[1] < 0
action_diverging(judgment, @action_data[3])
end
#--------------------------------------------------------------------------
# ● 条件分岐 (ゲーム変数)
#--------------------------------------------------------------------------
def nece_2
variable = $game_variables[@action_data[1]]
num = @action_data[2]
num = $game_variables[@action_data[2].abs] if num < 0
case @action_data[3]
when 0 ; judgment = variable == num
when 1 ; judgment = variable < num
when 2 ; judgment = variable > num
end
action_diverging(judgment, @action_data[4])
end
#--------------------------------------------------------------------------
# ● 条件分岐 (ステート)
#--------------------------------------------------------------------------
def nece_3
targets = N03.get_targets(@action_data[1], @battler)
return if targets == []
member_num = @action_data[4]
member_num = targets.size if @action_data[4] == 0 && targets.size > 1
hit_count = 0
miss_count = 0
for target in targets
hit_count += 1 if target.state?(@action_data[2])
miss_count += 1 if !target.state?(@action_data[2])
end
case @action_data[3]
when 0 ; judgment = hit_count >= member_num
when 1 ; judgment = miss_count >= member_num
end
action_diverging(judgment, @action_data[5])
end
#--------------------------------------------------------------------------
# ● 条件分岐 (スキル)
#--------------------------------------------------------------------------
def nece_4
targets = N03.get_targets(@action_data[1], @battler)
return if targets == []
member_num = @action_data[4]
member_num = targets.size if @action_data[4] == 0 && targets.size > 1
hit_count = 0
miss_count = 0
for target in targets
hit_count += 1 if target.skill_learn?($data_skills[@action_data[2]]) && target.skill_conditions_met?($data_skills[@action_data[2]])
miss_count += 1 if !target.skill_learn?($data_skills[@action_data[2]]) or !target.skill_conditions_met?($data_skills[@action_data[2]])
end
case @action_data[3]
when 0 ; judgment = hit_count >= member_num
when 1 ; judgment = miss_count >= member_num
end
action_diverging(judgment, @action_data[5])
end
#--------------------------------------------------------------------------
# ● 条件分岐 (パラメータ)
#--------------------------------------------------------------------------
def nece_5
targets = N03.get_targets(@action_data[1], @battler)
return if targets == []
member_num = @action_data[5]
member_num = targets.size if @action_data[5] == 0 && targets.size > 1
hit_count = 0
for target in targets
hit_count += 1 if target.comparison_parameter([@action_data[2],@action_data[3],@action_data[4]])
end
judgment = hit_count >= member_num
action_diverging(judgment, @action_data[6])
end
#--------------------------------------------------------------------------
# ● 条件分岐 (装備)
#--------------------------------------------------------------------------
def nece_6
targets = N03.get_targets(@action_data[1], @battler)
return if targets == []
member_num = @action_data[5]
member_num = targets.size if @action_data[5] == 0 && targets.size > 1
hit_count = 0
miss_count = 0
for target in targets
hit_count += 1 if target.comparison_equip([@action_data[2],@action_data[3]])
miss_count += 1 if !target.comparison_equip([@action_data[2],@action_data[3]])
end
case @action_data[4]
when 0 ; judgment = hit_count >= member_num
when 1 ; judgment = miss_count >= member_num
end
action_diverging(judgment, @action_data[6])
end
#--------------------------------------------------------------------------
# ● 条件分岐 (スクリプト)
#--------------------------------------------------------------------------
def nece_7
judgment = eval(@action_data[2])
action_diverging(judgment, @action_data[1])
end
#--------------------------------------------------------------------------
# ● アクション分岐
#--------------------------------------------------------------------------
def action_diverging(judgment, kind)
result = 0
if judgment
result = 1 if kind == 1
result = 2 if kind == 2
else
result = 1 if kind == 0
end
# ﾌﾙｱｸｼｮﾝ終了
return @full_action = [] if result == 2
# 次のｱｸｼｮﾝを除去
@full_action.shift if result == 1
set_action
# 次のｱｸｼｮﾝを実行
@action_data = N03::ACTION[@action]
next_action
end
#--------------------------------------------------------------------------
# ● セカンドターゲット操作
#--------------------------------------------------------------------------
def second_targets_set
targets = N03.get_targets(@action_data[1], @battler)
for target in targets
targets.delete(target) if @action_data[2][1] == 1 && target.index != @action_data[2][0]
targets.delete(target) if @action_data[2][1] == 2 && target.index == @action_data[2][0].abs
targets.delete(target) if @action_data[3] > 0 && target.id != @action_data[3]
targets.delete(target) if @action_data[3] < 0 && target.id == @action_data[3].abs
targets.delete(target) if @action_data[4] > 0 && !target.state?(@action_data[4])
targets.delete(target) if @action_data[4] < 0 && target.state?(@action_data[4].abs)
targets.delete(target) if @action_data[5] > 0 && !target.skill_conditions_met?($data_skills[@action_data[5]])
targets.delete(target) if @action_data[5] < 0 && target.skill_conditions_met?($data_skills[@action_data[5].abs])
targets.delete(target) if !target.comparison_parameter(@action_data[6])
targets.delete(target) if !@action_data[7][1].include?(0) && !target.comparison_equip(@action_data[7])
end
return @second_targets = [] if targets.size == 0
case @action_data[8]
when 1 ; targets = [targets[rand(targets.size)]]
when 2 ; targets.delete(@battler)
end
return @second_targets = [] if targets.size == 0
@second_targets = targets
case @action_data[9]
when 0 ; return
when 1 ; set_play_data(["second_targets_set"])
when 2 ; set_play_data(["targets_set"])
end
@wait += 1
end
#--------------------------------------------------------------------------
# ● ダメージアニメ
#--------------------------------------------------------------------------
def damage_anime(delay_time = 12)
anime(N03.get_attack_anime_id(-3, @battler), wait = true)
action_play
@wait -= delay_time
@full_action.unshift("eval('@damage_anime_data = []
@set_damage = true')")
end
#--------------------------------------------------------------------------
# ● 通常コラプス
#--------------------------------------------------------------------------
def normal_collapse
@collapse = true
return
end
#--------------------------------------------------------------------------
# ● 初期位置変更
#--------------------------------------------------------------------------
def change_base_position
@base_x = @x
@base_y = @y
@base_h = @h
end
#--------------------------------------------------------------------------
# ● 強制アクション実行
#--------------------------------------------------------------------------
def force_act
target(@full_action.shift)
end
#--------------------------------------------------------------------------
# ● 強制アクション実行 (セカンドターゲット)
#--------------------------------------------------------------------------
def force_act2
target2(@full_action.shift)
end
#--------------------------------------------------------------------------
# ● 個別処理開始
#--------------------------------------------------------------------------
def individual_start
@individual_targets = @target_battler.dup
@remain_targets = @target_battler.dup
@target_battler = [@individual_targets[0]]
# リピート部分のアクションを保持
@individual_act = @full_action.dup
end
#--------------------------------------------------------------------------
# ● 個別処理終了
#--------------------------------------------------------------------------
def individual_end
@individual_targets.shift
for target in @individual_targets
@individual_targets.shift if target.dead?
end
# ターゲットが残っているなら行動リピート
return @target_battler = @remain_targets if @individual_targets.size == 0
@full_action = @individual_act.dup
@target_battler = [@individual_targets[0]]
end
#--------------------------------------------------------------------------
# ● ループ開始
#--------------------------------------------------------------------------
def loop_start
# ループ部分のアクションを保持
@loop_act = @full_action.dup
end
#--------------------------------------------------------------------------
# ● ループ終了
#--------------------------------------------------------------------------
def loop_end
# 行動リピート
@full_action = @loop_act.dup if @loop_act != []
end
#--------------------------------------------------------------------------
# ● 次の行動者へ移行
#--------------------------------------------------------------------------
def next_battler
@action_end = true
@active = false
end
#--------------------------------------------------------------------------
# ● 画像変更フラグ
#--------------------------------------------------------------------------
def set_change
@change_up = true
end
#--------------------------------------------------------------------------
# ● 戦闘シーン通信
#--------------------------------------------------------------------------
def play_data
data = @play_data
@play_data = []
return data
end
#--------------------------------------------------------------------------
# ● ショートカットコマンド
#--------------------------------------------------------------------------
def anime(anime_id, wait = true)
@action_data = ["anime",anime_id,1,false,wait,false,true,false]
end
def anime_me(anime_id, wait = true)
@action_data = ["anime",anime_id,0,false,wait,false,true,false]
end
def se(file, pitch = 100)
@action_data = ["sound", "se", pitch, 100, file]
end
def target(act)
for target in @target_battler do target.sv.force_action = act end
end
def target2(act)
for target in @second_targets do target.sv.force_action = act end
end
def delay(time)
@wait = @battler.index * time
end
#--------------------------------------------------------------------------
# ● バトラーのIDを取得
#--------------------------------------------------------------------------
def id
return @battler.id if @battler.actor?
return [email protected]
end
#--------------------------------------------------------------------------
# ● 被クリティカルフラグを取得
#--------------------------------------------------------------------------
def critical?
return @battler.result.critical
end
#--------------------------------------------------------------------------
# ● 被回復フラグを取得
#--------------------------------------------------------------------------
def recovery?
recovery = false
recovery = true if @battler.result.hp_damage < 0
recovery = true if @battler.result.mp_damage < 0
recovery = true if @battler.result.tp_damage < 0
return recovery
end
#--------------------------------------------------------------------------
# ● 被スキルIDを取得
#--------------------------------------------------------------------------
def damage_skill_id
return @damage_skill_id
end
#--------------------------------------------------------------------------
# ● 被アイテムIDを取得
#--------------------------------------------------------------------------
def damage_item_id
return @damage_item_id
end
#--------------------------------------------------------------------------
# ● 装備武器を取得
#--------------------------------------------------------------------------
def weapon_id
return 0 if [email protected][0]
return @battler.weapons[0].id
end
#--------------------------------------------------------------------------
# ● 装備武器のタイプを取得
#--------------------------------------------------------------------------
def weapon_type
return 0 if [email protected][0]
return @battler.weapons[0].wtype_id
end
#--------------------------------------------------------------------------
# ● 盾を装備しているか
#--------------------------------------------------------------------------
def shield?
for armor in @battler.armors do return true if armor != nil && armor.etype_id == 1 end
return false
end
#--------------------------------------------------------------------------
# ● ダメージがあるか
#--------------------------------------------------------------------------
def damage_zero?
return @battler.result.hp_damage == 0 && @battler.result.mp_damage == 0 && @battler.result.tp_damage == 0
end
#--------------------------------------------------------------------------
# ● スキルIDを取得
#--------------------------------------------------------------------------
def skill_id
return @counter_id if @counter_id != 0
return 0 if @battler.current_action == nil or @battler.current_action.item == nil
return 0 if @battler.current_action.item.is_a?(RPG::Item)
return @battler.current_action.item.id
end
#--------------------------------------------------------------------------
# ● スキルのタイプを取得
#--------------------------------------------------------------------------
def skill_type
return 0 if skill_id == 0
return $data_skills[skill_id].stype_id
end
#--------------------------------------------------------------------------
# ● スキル名を取得
#--------------------------------------------------------------------------
def skill_name
return "" if skill_id == 0
return $data_skills[skill_id].name
end
#--------------------------------------------------------------------------
# ● アイテムIDを取得
#--------------------------------------------------------------------------
def item_id
return 0 if @battler.current_action == nil or @battler.current_action.item == nil
return @battler.current_action.item.id
end
#--------------------------------------------------------------------------
# ● 攻撃アクション
#--------------------------------------------------------------------------
def attack_action(item)
return skill_action if item.is_a?(RPG::Skill)
return item_action
end
#--------------------------------------------------------------------------
# ● ダメージアクションベース
#--------------------------------------------------------------------------
def damage_action_base(item)
@damage_skill_id = 0
@damage_item_id = 0
@damage_skill_id = item.id if item.is_a?(RPG::Skill)
@damage_item_id = item.id if item.is_a?(RPG::Item)
end
#--------------------------------------------------------------------------
# ● ダメージアクション
#--------------------------------------------------------------------------
def damage_action(attacker, item)
damage_action_base(item)
act = damage(attacker)
return if @active
start_action(act) if act != nil
end
#--------------------------------------------------------------------------
# ● 回避アクション
#--------------------------------------------------------------------------
def evasion_action(attacker, item)
damage_action_base(item)
act = evasion(attacker)
return if @active
start_action(act) if act != nil
end
#--------------------------------------------------------------------------
# ● ミスアクション
#--------------------------------------------------------------------------
def miss_action(attacker, item)
damage_action_base(item)
act = miss(attacker)
return if @active
start_action(act) if act != nil
end
#--------------------------------------------------------------------------
# ● 閃きスクリプト併用処理
#--------------------------------------------------------------------------
def flash_action
return "閃き"
end
end
#==============================================================================
# ■ module N03
#------------------------------------------------------------------------------
# 　サイドビューバトルのモジュールです。
#==============================================================================
module N03
#--------------------------------------------------------------------------
# ● バトラーの敵グループを取得
#--------------------------------------------------------------------------
def self.get_enemy_unit(battler)
return $game_troop if battler.actor?
return $game_party
end
#--------------------------------------------------------------------------
# ● バトラーの味方グループを取得
#--------------------------------------------------------------------------
def self.get_party_unit(battler)
return $game_party if battler.actor?
return $game_troop
end
#--------------------------------------------------------------------------
# ● 戦闘アニメ時間の取得
#--------------------------------------------------------------------------
def self.get_anime_time(anime_id)
return 0 if anime_id <= 0
return $data_animations[anime_id].frame_max * 4
end
#--------------------------------------------------------------------------
# ● 攻撃アニメの取得
#--------------------------------------------------------------------------
def self.get_attack_anime_id(kind, battler)
return $data_skills[battler.sv.counter_id].animation_id if kind == -3 && battler.sv.counter_id != 0
case kind
when -1 ; anime_id = battler.atk_animation_id1
when -2 ; anime_id = battler.atk_animation_id2
when -3
if battler.current_action != nil
anime_id = battler.current_action.item.animation_id if battler.current_action.item != nil
end
else ; anime_id = kind
end
case anime_id
when -1 ; anime_id = battler.atk_animation_id1
when -2 ; anime_id = battler.atk_animation_id2
end
return anime_id if anime_id
return 0
end
#--------------------------------------------------------------------------
# ● 戦闘アニメデータをセット
#--------------------------------------------------------------------------
def self.set_damage_anime_data(targets, target, data)
return if !first_of_all_screen_anime(data[0], target, targets)
target.animation_id = data[0]
target.animation_mirror = data[1]
target.sv.anime_no_mirror = data[2]
target.sv.anime_camera_zoom = data[3]
target.sv.anime_plus_z = data[4]
end
#--------------------------------------------------------------------------
# ● ターゲットの取得
#--------------------------------------------------------------------------
def self.get_targets(kind, battler)
case kind.abs
when 0 ; return [battler].dup
when 1 ; return battler.sv.target_battler.dup
when 2 ; return get_enemy_unit(battler).members.dup
when 3 ; return get_party_unit(battler).members.dup
when 4 ; return $game_troop.members.dup + $game_party.battle_members.dup
when 5 ; return battler.sv.second_targets.dup
end
end
#--------------------------------------------------------------------------
# ● ターゲットの座標を取得
#--------------------------------------------------------------------------
def self.get_targets_position(targets, horming, m_a = nil)
return [0,0,0] if targets == nil && !$sv_camera.mirror
return [Graphics.width,0,0] if targets == nil && $sv_camera.mirror
x = y = h = 0
for i in 0...targets.size
x += targets[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
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 [email protected] or @data[9] != ""
return @action_end = true if [email protected]
@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 [email protected]
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)/ 100
@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 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 = @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)/ 100
@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 [email protected] do update_state_move(@st[i], i) end if @st != nil
for i in [email protected] 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 = 0
bitmap.dispose if bitmap
for i in [email protected] do @num[i].dispose end if @num != nil
for i in [email protected] 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 [email protected]
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 [email protected]
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 [email protected]
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 [email protected]
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 [email protected]
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 # バトルプログラム周期ピクチャ
#--------------------------------------------------------------------------
# ● オブジェクト初期化
#--------------------------------------------------------------------------
def initialize
@switches = []
@max_data = []
@color_set = []
@wait = 0
@win_wait = false
@mirror = 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
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
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 [email protected]
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 [email protected]?
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
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
@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
@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
@real_x = x if !@real_x
@real_y = y if !@real_y
@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? && @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
camera_x = $sv_camera.x
camera_y = $sv_camera.y
camera_x = 0 if @animation.position == 3
camera_y = 0 if @animation.position == 3
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
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 [email protected]?
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 [email protected]?
@battler.sv.set_graphics(self.bitmap.width, self.bitmap.height)
end
self.src_rect.set(@battler.sv.sx, @battler.sv.sy, @battler.sv.cw, @battler.sv.ch)
self.opacity = @battler.sv.opacity
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 = [email protected] 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 [email protected]_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 [email protected]
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 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
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
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_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
#==============================================================================
#
# ▼ YSA Battle System: Predicted Charge Turn Battle
# -- Last Updated: 2012.02.20
# -- Level: Easy, Normal
# -- Requires: n/a
#
#==============================================================================
$imported = {} if $imported.nil?
$imported["YSA-PCTB"] = true
#==============================================================================
# ▼ Updates
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# 2012.02.20 - Reduced lag a little.
# 2012.02.19 - Fixed: Press Left/Right when choose action for actor.
# - Script now can work alone, without YEA - Battle Engine Ace.
# 2012.02.16 - Finished Script.
# 2012.02.07 - Started Script.
#
#==============================================================================
# ▼ Introduction
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# Battle Type: Predicted CTB.
#
#==============================================================================
# ▼ Instructions
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# To install this script, open up your script editor and copy/paste this script
# to an open slot below ▼ Materials/素材 but above ▼ Main. Remember to save.
#
# To get this work with YEA - Ace Battle Engine, set the default battle system
# for your game to be :pctb by either going to the Ace Battle Engine script and
# setting DEFAULT_BATTLE_SYSTEM as :pctb or by using the following script call:
#
# $game_system:set_battle_system(:pctb)
#
# -----------------------------------------------------------------------------
# Skill and Item Database
# -----------------------------------------------------------------------------
# SPEED FIX
# ~ When set SPEED FIX to a number larger than 0, battler's Speed will be reseted
# by value, equal to SPEED_FIX * :speed_rate.
# ~ When set SPEED FIX to a number smaller than 0, battler's Speed will be
# reduced by value, equal to SPEED_FIX * :speed_rate. This Skill/Item will be
# counted as a charging skill/item.
#
# -----------------------------------------------------------------------------
# Skill and Item Notetags
# -----------------------------------------------------------------------------
# <charge rate: x%>
# Change battler's speed rate when charging a skill or item.
#
# <ctb cost: x%> or <ctb cost: x>
# Decide how much Speed will be reduced after an action.
# If it's a percent, Battler's Speed will be reduced x percents of Max Threshold.
# If it's a normal value, Battler's Speed will be reduced by x.
# Default: CTB COST 100% in percent and 0 in value
#
# <ctb change: +x%> or <ctb change: +x>
# <ctb change: -x%> or <ctb change: -x>
# Change target's Speed when use this skill/item.
# If it's a percent, Battler's Speed will be increase or decrease x percents of
# Max Threshold.
# If it's a normal value, Battler's Speed will be increase or decrease by x.
#
#==============================================================================
# ▼ Compatibility
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script is made strictly for RPG Maker VX Ace. It is highly unlikely that
# it will run with RPG Maker VX without adjusting.
#
# This script is compatible with Yanfly Engine Ace - Ace Battle Engine v1.15+
# and the script must be placed under Ace Battle Engine in the script listing.
#
#==============================================================================
#==============================================================================
# ▼ Configuration
#==============================================================================
module YSA
module PCTB
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Mechanic Configuration -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
CTB_MECHANIC = { # Start
:dyn_threshold => true,
# Threshold Offset. If Dynamic Threshold is set to false, this will be
# threshold
:threshold_offset => 400,
# For Dynamic Threshold
:threshold_min => 800,
:threshold_rate => 4.0,
# Ticks per turn
:turn_ctr => 32,
:wait_after_turn => 5, # Frames
# Predict Type
# Type 0: Show Battlers Order only.
# Type 1: Show Battlers Order and Re-order when active battler chooses
# an action.
# Type 2: Show Battlers Order in X Turns (FFX Style).
:predict => 2,
:pre_turns => 8,
} # Do not remove this.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Battler Configuration -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
BATTLER_RULES = { # Start
# Speed offset when reset, multiply with Skill/Item speed
:speed_rate => 16.0,
:speed_limit => 0.75, # Set to 0 to disable limit.
# Initialize speed
:initial => 0.10,
:surprise => 0.75,
:random_rate => 8.0, # Multiply with AGI.
# Charging Term
:charge_text => "正在准备！",#"%s is charging %s!",
:charge_text_dur => 4,
# Can't take action Term
:cant_text => "无法行动！",#"%s cannot take an action!",
:cant_text_dur => 4,
:show_cant_text => true,
} # Do not remove this.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Event Configuration -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
CTB_COMMON_EVENT = { # Start
# Set to 0 to disable this.
:turn_update => 0, # Run common event whenever turn updates.
:end_action => 0, # Run common event whenever an action finishes.
} # Do not remove this.
end
end
#==============================================================================
# ▼ Editting anything past this point may potentially result in causing
# computer damage, incontinence, explosion of user's head, coma, death, and/or
# halitosis so edit at your own risk.
#==============================================================================
module YSA
module REGEXP
module USABLEITEM
CHARGE_RATE = /<(?:CHARGE_RATE|charge rate):[ ](\d+)?([%％])>/i
CTB_COST_PER = /<(?:CTB_COST|ctb cost):[ ](\d+)?([%％])>/i
CTB_COST_VAL = /<(?:CTB_COST|ctb cost):[ ](\d+)?>/i
CHANGE_CTB_PER = /<(?:CTB_CHANGE|ctb change):[ ]([\+\-]\d+)([%％])?>/i
CHANGE_CTB_VAL = /<(?:CTB_CHANGE|ctb change):[ ]([\+\-]\d+)?>/i
end # USABLEITEM
end # REGEXP
end # YSA
#==============================================================================
# ■ DataManager
#==============================================================================
module DataManager
#--------------------------------------------------------------------------
# alias method: load_database
#--------------------------------------------------------------------------
class <<self; alias load_database_pctb load_database; end
def self.load_database
load_database_pctb
load_notetags_pctb
end
#--------------------------------------------------------------------------
# new method: load_notetags_pctb
#--------------------------------------------------------------------------
def self.load_notetags_pctb
groups = [$data_skills, $data_items]
for group in groups
for obj in group
next if obj.nil?
obj.load_notetags_pctb
end
end
end
end # DataManager
#==============================================================================
# ■ RPG::UsableItem
#==============================================================================
class RPG::UsableItem < RPG::BaseItem
#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :charge_rate
attr_accessor :ctb_cost
attr_accessor :ctb_cost_val
attr_accessor :ctb_change
attr_accessor :ctb_change_val
#--------------------------------------------------------------------------
# common cache: load_notetags_pctb
#--------------------------------------------------------------------------
def load_notetags_pctb
@charge_rate = 100
@ctb_cost = 100
@ctb_cost_val = 0
@ctb_change = 0
@ctb_change_val = 0
#---
self.note.split(/[\r\n]+/).each { |line|
case line
#---
when YSA::REGEXP::USABLEITEM::CHARGE_RATE
@charge_rate = $1.to_i
when YSA::REGEXP::USABLEITEM::CTB_COST_PER
@ctb_cost = $1.to_i
when YSA::REGEXP::USABLEITEM::CTB_COST_VAL
@ctb_cost_val = $1.to_i
when YSA::REGEXP::USABLEITEM::CHANGE_CTB_PER
@ctb_change = $1.to_i
when YSA::REGEXP::USABLEITEM::CHANGE_CTB_VAL
@ctb_change_val = $1.to_i
#---
end
} # self.note.split
#---
@charge_rate = 100 if @charge_rate <= 0
@ctb_cost = 100 if @ctb_cost > 100
end
end # RPG::UsableItem
#==============================================================================
# ■ BattleManager
#==============================================================================
module BattleManager
#--------------------------------------------------------------------------
# alias method:
# - make_action_orders
# - prior_command
# - next_command
# - in_turn?
# - battle_start
#--------------------------------------------------------------------------
class <<self
alias pctb_make_action_orders make_action_orders
alias pctb_prior_command prior_command
alias pctb_next_command next_command
alias pctb_next_subject next_subject
alias pctb_battle_start battle_start
alias pctb_input_start input_start
alias pctb_turn_start turn_start
end
#--------------------------------------------------------------------------
# battle_start
#--------------------------------------------------------------------------
def self.battle_start
pctb_battle_start
if btype?(:pctb)
make_pctb_action_orders
make_pctb_threshold
make_pctb_first_speed
end
end
#--------------------------------------------------------------------------
# make_action_orders
#--------------------------------------------------------------------------
def self.make_action_orders
return if btype?(:pctb)
pctb_make_action_orders unless btype?(:pctb)
end
#--------------------------------------------------------------------------
# next_command
#--------------------------------------------------------------------------
def self.next_command
return false if btype?(:pctb)
pctb_next_command
end
#--------------------------------------------------------------------------
# prior_command
#--------------------------------------------------------------------------
def self.prior_command
return false if btype?(:pctb)
pctb_prior_command
end
#--------------------------------------------------------------------------
# new method: make_pctb_action_orders
#--------------------------------------------------------------------------
def self.make_pctb_action_orders
@action_battlers = []
end
#--------------------------------------------------------------------------
# new method: make_pctb_threshold
#--------------------------------------------------------------------------
def self.make_pctb_threshold
@threshold = YSA::PCTB::CTB_MECHANIC[:threshold_offset]
return unless YSA::PCTB::CTB_MECHANIC[:dyn_threshold]
offset = 0
battlers = $game_party.members + $game_troop.members
battlers.each { |battler|
offset += battler.agi
}
@threshold += offset * YSA::PCTB::CTB_MECHANIC[:threshold_rate]
@threshold = @threshold >= YSA::PCTB::CTB_MECHANIC[:threshold_min] ? @threshold : YSA::PCTB::CTB_MECHANIC[:threshold_min]
end
#--------------------------------------------------------------------------
# new method: make_pctb_first_speed
#--------------------------------------------------------------------------
def self.make_pctb_first_speed
init_value = YSA::PCTB::BATTLER_RULES[:initial] * pctb_threshold
surprise_value = YSA::PCTB::BATTLER_RULES[:surprise] * pctb_threshold
battlers = $game_party.members + $game_troop.members
battlers.each { |battler|
check = (battler.actor? && @preemptive) || (battler.enemy? && @surprise)
battler.pctb_speed = init_value
battler.pctb_speed = surprise_value if check
random = YSA::PCTB::BATTLER_RULES[:random_rate] * battler.agi + 1
battler.pctb_speed += rand(random)
}
end
#--------------------------------------------------------------------------
# new method: pctb_threshold
#--------------------------------------------------------------------------
def self.pctb_threshold
return @threshold
end
#--------------------------------------------------------------------------
# new method: set_actor
#--------------------------------------------------------------------------
def self.set_actor(actor_index)
@actor_index = actor_index
end
#--------------------------------------------------------------------------
# new method: action_list_ctb
#--------------------------------------------------------------------------
def self.action_list_ctb
return @action_battlers
end
#--------------------------------------------------------------------------
# alias method: next_subject
#--------------------------------------------------------------------------
def self.next_subject
return pctb_next_subject unless btype?(:pctb)
loop do
battler = @action_battlers[0]
return nil unless battler
unless battler.index && battler.alive?
@action_battlers.shift
next
end
return battler
end
end
#--------------------------------------------------------------------------
# alias method: input_start
#--------------------------------------------------------------------------
def self.input_start
return pctb_input_start unless btype?(:pctb)
@phase = :input
return false
end
#--------------------------------------------------------------------------
# alias method: turn_start
#--------------------------------------------------------------------------
def self.turn_start
return pctb_turn_start unless btype?(:pctb)
@phase = :turn
clear_actor
end
#--------------------------------------------------------------------------
# alias method: turn_start
#--------------------------------------------------------------------------
def self.sort_battlers(cache = false)
if btype?(:pctb)
battlers = []
for battler in ($game_party.members + $game_troop.members)
next if battler.dead?
battlers.push(battler)
end
battlers.sort! { |a,b|
if a.pctb_ctr(cache) != b.pctb_ctr(cache)
a.pctb_ctr(cache) <=> b.pctb_ctr(cache)
elsif a.pctb_prediction != b.pctb_prediction
b.pctb_prediction <=> a.pctb_prediction
elsif a.agi != b.agi
b.agi <=> a.agi
elsif a.screen_x != b.screen_x
a.screen_x <=> b.screen_x
else
a.name <=> b.name
end
}
return battlers
end
end
#--------------------------------------------------------------------------
# new method: btype?
#--------------------------------------------------------------------------
def self.btype?(btype)
return true if btype == :pctb
end
end # BattleManager
#==============================================================================
# ■ Game_Battler
#==============================================================================
class Game_Battler < Game_BattlerBase
#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :pctb_speed
attr_accessor :pctb_prediction
attr_accessor :last_obj
attr_accessor :pctb_forced
attr_accessor :pctb_speed_cache
#--------------------------------------------------------------------------
# alias method: initialize
#--------------------------------------------------------------------------
alias pctb_initialize initialize
def initialize
pctb_initialize
@pctb_speed = 0
@pctb_prediction = 0
@pctb_speed_cache = 0
end
#--------------------------------------------------------------------------
# new method: base_gain_pctb
#--------------------------------------------------------------------------
def base_gain_pctb
return self.agi
end
#--------------------------------------------------------------------------
# new method: real_gain_pctb
#--------------------------------------------------------------------------
def real_gain_pctb
obj = current_action.item if current_action
value = base_gain_pctb
value = value * obj.charge_rate / 100 if obj && @charging_pctb
return value
end
#--------------------------------------------------------------------------
# new method: pctb_ctr
#--------------------------------------------------------------------------
def pctb_ctr(cache = false)
@pctb_prediction = @pctb_speed unless cache
@pctb_prediction = @pctb_speed_cache if cache
return 0 if @pctb_prediction >= BattleManager.pctb_threshold
value = (BattleManager.pctb_threshold.to_f - @pctb_prediction.to_f) / real_gain_pctb.to_f
value = value.ceil
@pctb_prediction += value * real_gain_pctb
return value
end
#--------------------------------------------------------------------------
# new method: reset_pctb_speed
#--------------------------------------------------------------------------
def reset_pctb_speed(cache = false)
return @pctb_forced = false if @pctb_forced
if actor?
obj = input ? input.item : @last_obj
else
obj = @last_obj
end
real_cache = @pctb_speed
if obj
limit_rate = YSA::PCTB::BATTLER_RULES[:speed_limit]
limit = BattleManager.pctb_threshold * limit_rate
real_cache -= obj.ctb_cost * BattleManager.pctb_threshold / 100
real_cache -= obj.ctb_cost_val
value = YSA::PCTB::BATTLER_RULES[:speed_rate] * obj.speed
value = [value, 0].max
value = [value, limit].min if limit > 0
real_cache += value
else
real_cache -= BattleManager.pctb_threshold
end
real_cache = [real_cache, 0].max
@pctb_speed = real_cache if cache == false
@pctb_speed_cache = real_cache if cache
@charging_pctb = false unless cache
@last_obj = nil unless cache
end
#--------------------------------------------------------------------------
# new method: charging_start
#--------------------------------------------------------------------------
def charging_start
return false unless BattleManager.btype?(:pctb)
return false if @charging_pctb
return false unless current_action
obj = current_action.item
return false unless obj
return false if obj.speed >= 0
value = obj.speed * YSA::PCTB::BATTLER_RULES[:speed_rate]
@pctb_speed += value
@pctb_speed = [@pctb_speed, 0].max
BattleManager.action_list_ctb.shift
@charging_pctb = true
SceneManager.scene.charging_start(self)
SceneManager.scene.update_pctb_speed
return true
end
#--------------------------------------------------------------------------
# new method: pctb_active?
#--------------------------------------------------------------------------
def pctb_active?
return @pctb_speed >= BattleManager.pctb_threshold && movable?
end
#--------------------------------------------------------------------------
# new method: storage_speed
#--------------------------------------------------------------------------
def storage_speed
return if @cache_speed
@cache_speed = @pctb_speed
end
#--------------------------------------------------------------------------
# new method: restore_speed
#--------------------------------------------------------------------------
def restore_speed
return unless @cache_speed
@pctb_speed = @cache_speed
@cache_speed = nil
end
#--------------------------------------------------------------------------
# alias method: update_state_turns
#--------------------------------------------------------------------------
alias pctb_update_state_turns update_state_turns
def update_state_turns
if BattleManager.btype?(:pctb)
states.each do |state|
@state_turns[state.id] -= 1 if @state_turns[state.id] > 0 && state.auto_removal_timing == 2
end
else
pctb_update_state_turns
end
end
#--------------------------------------------------------------------------
# new method: update_state_actions
#--------------------------------------------------------------------------
def update_state_actions
return unless BattleManager.btype?(:pctb)
states.each do |state|
@state_turns[state.id] -= 1 if @state_turns[state.id] > 0 && state.auto_removal_timing == 1
end
end
#--------------------------------------------------------------------------
# alias method: on_action_end
#--------------------------------------------------------------------------
alias pctb_on_action_end on_action_end
def on_action_end
pctb_on_action_end
update_state_actions
end
#--------------------------------------------------------------------------
# alias method: force_action
#--------------------------------------------------------------------------
alias pctb_force_action force_action
def force_action(skill_id, target_index)
if BattleManager.btype?(:pctb)
action = Game_Action.new(self, true)
action.set_skill(skill_id)
if target_index == -2
action.target_index = last_target_index
elsif target_index == -1
action.decide_random_target
else
action.target_index = target_index
end
@actions = [action] + @actions
@pctb_forced = true
end
pctb_force_action(skill_id, target_index) unless BattleManager.btype?(:pctb)
end
#--------------------------------------------------------------------------
# alias method: make_action_times
#--------------------------------------------------------------------------
alias pctb_make_action_times make_action_times
def make_action_times
BattleManager.btype?(:pctb) ? 1 : pctb_make_action_times
end
end # Game_Battler
#==============================================================================
# ■ Scene_Battle
#==============================================================================
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# new method: battle_start
#--------------------------------------------------------------------------
alias pctb_battle_start battle_start
def battle_start
pctb_battle_start
update_pctb_speed
end
#--------------------------------------------------------------------------
# new method: charging_start
#--------------------------------------------------------------------------
def charging_start(battler)
@status_window.show
@status_window.open
if $imported["YEA-BattleEngine"]
redraw_current_status
@status_aid_window.hide
else
refresh_status
end
@actor_command_window.show
string = YSA::PCTB::BATTLER_RULES[:charge_text]
skill = battler.current_action.item
skill_text = sprintf("\\i[%d]%s", skill.icon_index, skill.name)
text = sprintf(string, battler.name, skill_text)
@log_window.add_text(text)
YSA::PCTB::BATTLER_RULES[:charge_text_dur].times do @log_window.wait end
@log_window.back_one
end
#--------------------------------------------------------------------------
# new method: update_pctb_speed
#--------------------------------------------------------------------------
def update_pctb_speed
return if scene_changing?
@clocktick = 0 if @clocktick.nil?
ctr = YSA::PCTB::CTB_MECHANIC[:turn_ctr]
#---
battlers = BattleManager.sort_battlers
first_battler = battlers[0]
tick = first_battler.pctb_ctr
#---
battlers.each { |battler|
battler.pctb_speed += tick * battler.real_gain_pctb
}
#---
@clocktick = @clocktick + tick
pass_turn = @clocktick / ctr
pass_turn = pass_turn.floor.to_i
pass_turn.times {
$game_temp.reserve_common_event(YSA::PCTB::CTB_COMMON_EVENT[:turn_update]) if YSA::PCTB::CTB_COMMON_EVENT[:turn_update] > 0 && $data_common_events[YSA::PCTB::CTB_COMMON_EVENT[:turn_update]]
process_event
$game_troop.increase_turn
turn_end
wait(YSA::PCTB::CTB_MECHANIC[:wait_after_turn])
}
@clocktick = @clocktick % ctr
#---
if first_battler.movable?
BattleManager.action_list_ctb.push(first_battler)
else
string = YSA::PCTB::BATTLER_RULES[:cant_text]
text = sprintf(string, first_battler.name)
@log_window.add_text(text)
YSA::PCTB::BATTLER_RULES[:cant_text_dur].times do @log_window.wait end
@log_window.back_one
first_battler.clear_actions
first_battler.reset_pctb_speed
return update_pctb_speed && update_order_gauge
end
#---
update_order_gauge
#---
start_pctb_action
end
#--------------------------------------------------------------------------
# new method: start_pctb_action
#--------------------------------------------------------------------------
def start_pctb_action
battler = BattleManager.action_list_ctb[0]
battler.make_actions if battler.actions.size == 0
return if battler.charging_start && battler.enemy?
if battler.actor? && battler.input && battler.input.item.nil?
BattleManager.input_start
BattleManager.set_actor(battler.index)
start_actor_command_selection
if $imported["YEA-BattleEngine"]
redraw_current_status
@status_aid_window.hide
else
refresh_status
end
@status_window.show
@status_window.open
end
turn_start if battler.enemy?
turn_start if battler.actor? && battler.input && battler.input.item
end
#--------------------------------------------------------------------------
# new method: update_order_gauge
#--------------------------------------------------------------------------
def update_order_gauge
battler = BattleManager.action_list_ctb[0]
return unless $imported["YSA-OrderBattler"]
BattleManager.make_ctb_battler_order
@active_order_sprite.battler = battler if @active_order_sprite
for order in @spriteset_order
order.make_destination
end
end
#--------------------------------------------------------------------------
# alias method: execute_action
#--------------------------------------------------------------------------
alias scene_battle_execute_action_pctb execute_action
def execute_action
scene_battle_execute_action_pctb
unless BattleManager.action_forced?
unless @subject.current_action.nil?
@subject.last_obj = @subject.current_action.item unless @subject.last_obj
end
end
end
#--------------------------------------------------------------------------
# alias method: execute_action
#--------------------------------------------------------------------------
alias scene_battle_invoke_item_pctb invoke_item
def invoke_item(target, item)
scene_battle_invoke_item_pctb(target, item)
#---
change_per = item.ctb_change * BattleManager.pctb_threshold / 100
change_val = item.ctb_change_val
target.pctb_speed += change_per
target.pctb_speed = 0 if target.pctb_speed < 0
target.pctb_speed += change_val
target.pctb_speed = 0 if target.pctb_speed < 0
#---
end
#--------------------------------------------------------------------------
# alias method: process_action_end
#--------------------------------------------------------------------------
alias scene_battle_process_action_end_pctb process_action_end
def process_action_end
scene_battle_process_action_end_pctb
unless BattleManager.action_forced?
$game_temp.reserve_common_event(YSA::PCTB::CTB_COMMON_EVENT[:end_action]) if YSA::PCTB::CTB_COMMON_EVENT[:end_action] > 0 && $data_common_events[YSA::PCTB::CTB_COMMON_EVENT[:end_action]]
process_event
@subject.restore_speed
@subject.reset_pctb_speed
return start_pctb_action if @subject.pctb_active?
BattleManager.action_list_ctb.shift
update_pctb_speed
end
end
#--------------------------------------------------------------------------
# alias method: next_command
#--------------------------------------------------------------------------
alias pctb_next_command next_command
def next_command
if BattleManager.actor
if BattleManager.actor != BattleManager.action_list_ctb[0]
BattleManager.action_list_ctb[0].make_actions
start_pctb_action
return
end
end
return @subject = nil if BattleManager.actor && BattleManager.actor.charging_start
pctb_next_command
end
#--------------------------------------------------------------------------
# alias method: create_actor_command_window
#--------------------------------------------------------------------------
alias yctb_create_actor_command_window create_actor_command_window
def create_actor_command_window
yctb_create_actor_command_window
@actor_command_window.set_handler(:cancel, method(:ctb_prior_actor))
@actor_command_window.set_handler(:dir4, method(:ctb_prior_actor))
@actor_command_window.set_handler(:dir6, method(:ctb_next_command))
end
#--------------------------------------------------------------------------
# new method: ctb_prior_actor
#--------------------------------------------------------------------------
def ctb_prior_actor
BattleManager.actor.make_actions
last_index = BattleManager.actor.index
prior_index = last_index - 1
if prior_index < 0
@actor_command_window.close
@party_command_window.setup
else
return ctb_prior_actor if !$game_party.members[prior_index].movable?
$game_party.members[prior_index].make_actions
BattleManager.input_start
BattleManager.set_actor(prior_index)
start_actor_command_selection
if $imported["YEA-BattleEngine"]
redraw_current_status
@status_aid_window.hide
else
refresh_status
end
@status_window.show
@status_window.open
end
end
#--------------------------------------------------------------------------
# new method: ctb_next_command
#--------------------------------------------------------------------------
def ctb_next_command
BattleManager.actor.make_actions
last_index = BattleManager.actor.index
next_index = last_index + 1
if next_index > ($game_party.members.size - 1)
return start_confirm_command_selection if $imported["YEA-BattleCommandList"] && YEA::BATTLE_COMMANDS::USE_CONFIRM_WINDOW
BattleManager.action_list_ctb[0].make_actions
start_pctb_action
else
return ctb_next_command if !$game_party.members[next_index].movable?
$game_party.members[next_index].make_actions
BattleManager.input_start
BattleManager.set_actor(next_index)
start_actor_command_selection
if $imported["YEA-BattleEngine"]
redraw_current_status
@status_aid_window.hide
else
refresh_status
end
@status_window.show
@status_window.open
end
end
#--------------------------------------------------------------------------
# alias method: command_fight
#--------------------------------------------------------------------------
alias command_fight_pctb command_fight
def command_fight
return command_fight_pctb unless BattleManager.btype?(:pctb)
if BattleManager.action_list_ctb[0].nil?
update_pctb_speed
else
BattleManager.action_list_ctb[0].make_actions
start_pctb_action
end
end
#--------------------------------------------------------------------------
# alias method: turn_start
#--------------------------------------------------------------------------
alias pctb_turn_start turn_start
def turn_start
last_subject = @subject if BattleManager.btype?(:pctb)
pctb_turn_start
@subject = last_subject if BattleManager.btype?(:pctb)
end
end # Scene_Battle
#==============================================================================
#
# ▼ End of File
#
#==============================================================================

复制代码