Battle amélioré (Jauge ATB)

# ƒŠƒAƒ‹ƒ^ƒCƒ€�EƒAƒNƒeƒBƒuƒoƒgƒ‹(RTAB) Ver 1.05
# ”z•zŒ³�EƒTƒ|�[ƒgURL
# http://members.jcom.home.ne.jp/cogwheel/

class Scene_Battle
#--------------------------------------------------------------------------
# �œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï�”
#--------------------------------------------------------------------------
attr_reader :status_window # ƒXƒe�[ƒ^ƒXƒEƒBƒ“ƒhƒE
attr_reader :spriteset # ƒoƒgƒ‹ƒXƒvƒ‰ƒCƒg
attr_reader :scroll_time # ƒXƒNƒŠ�[ƒ“ˆÚ“®Šî–{ŽžŠÔ
attr_reader :zoom_rate # “Gƒoƒgƒ‰�[Šî–{ˆÊ’u
attr_reader :drive # ƒJƒ�ƒ‰‹ì“®
attr_accessor :force # ƒAƒNƒVƒ‡ƒ“‹­�§“x
attr_accessor :camera # Œ»�݂̃Jƒ�ƒ‰�ŠŽ�ŽÒ
#--------------------------------------------------------------------------
# �œ ATBŠî‘bƒZƒbƒgƒAƒbƒv
#--------------------------------------------------------------------------
def atb_setup
# ATB�‰Šú‰»
# speed : ƒoƒgƒ‹ƒXƒs�[ƒhŒˆ’è�B’l‚ª�¬‚³‚¢‚Ù‚Ç‘�‚¢
# @active : ƒAƒNƒeƒBƒu“x�Ý’è
# 3 : �í‚ɃAƒNƒeƒBƒu�ó‘Ô
# 2 : ƒXƒLƒ‹�EƒAƒCƒeƒ€‘I‘𒆂̂݃AƒNƒeƒBƒuƒQ�[ƒW‚ªŽ~‚Ü‚é
# 1 : 2‚Ì�ó‘ԂɉÁ‚¦�Aƒ^�[ƒQƒbƒg‘I‘ðŽž‚àƒEƒFƒCƒg‚ªŠ|‚©‚é
# 0 : 1‚Ì�ó‘ԂɉÁ‚¦�AƒRƒ}ƒ“ƒh“ü—ÍŽž‚É‚àƒEƒFƒCƒg‚ªŠ|‚©‚é
# @action : ‘¼�l‚ª�s“®’†‚ÉŽ©•ª‚à�s“®‚ð‹N‚±‚·‚±‚Æ‚ð‹–‚·‚©
# 3 : Ž©•ª‚ª�s“®•s”\‚Å‚È‚¢ŒÀ‚èŒÀ‚è‹–‚·
# 2 : Ž©•ª‚ªƒ_ƒ��[ƒW‚ðŽó‚¯‚Ä‚¢‚È‚¢ŒÀ‚è‹–‚·
# 1 : 2‚Ì�ó‘ԂɉÁ‚¦�Aƒ^�[ƒQƒbƒg‚ª�s“®‚µ‚Ä‚¢‚È‚¢ŒÀ‚è‹–‚·
# 0 : �s“®‚ð‹–‚³‚È‚¢�B�‡”Ô‚É�s“®‚µ�I‚¦‚é‚Ü‚Å‘Ò‚Â
# @anime_wait : true‚É‚·‚é‚ƃoƒgƒ‹ƒAƒjƒ��Eƒ_ƒ��[ƒW•\Ž¦’†‚̓EƒFƒCƒg‚ªŠ|‚©‚é
# @damage_wait : ƒ_ƒ��[ƒW•\Ž¦‘Ò‚¿ŽžŠÔ�i’PˆÊ‚̓tƒŒ�[ƒ€�j
# @enemy_speed : “G‚ÌŽv�l‘¬“x�B1‚Ȃ瑦Žž�s“®�B
# 1ƒtƒŒ�[ƒ€–ˆ‚É�A1/@enemy_speed‚ÌŠm—¦‚Å�s“®‚ð‹N‚±‚·
# @force : ‹­�§ƒAƒNƒVƒ‡ƒ“‚ŃXƒLƒ‹Žg—pŽž‚Ì‹­�§‹ï�‡
# 2:ƒXƒLƒ‹‚Í‘S‚ĉr�¥‚¹‚¸�A•K‚¸‘¦ŽžŽÀ�s
# 1:’P“ƃXƒLƒ‹‚͉r�¥‚µ�A˜AŒgƒXƒLƒ‹‚Ì‚Ý‘¦ŽžŽÀ�s
# 0:‘SƒXƒLƒ‹‰r�¥‚ð�s‚¤‚¾‚¯
# ($scene.force = x ‚Æ‚·‚邱‚Æ‚É‚æ‚è�A’Ê�íƒCƒxƒ“ƒg‚̃XƒNƒŠƒvƒg‚©‚ç•Ï�X‰Â”\�j
# @drive : ƒJƒ�ƒ‰‹ì“®ON/OFF�Btrue‚Å‹ì“®ON�Afalse‚Å‹ì“®OFF
# @scroll_time : ƒXƒNƒŠ�[ƒ“ˆÚ“®‚É—v‚·‚éŠî–{ŽžŠÔ
# @zoom_rate = [i, j] : ƒGƒlƒ~�[‚̃Y�[ƒ€—¦
# i ‚ª‰æ–Ê�Å�ã•”‚É”z’u‚µ‚½Žž‚ÌŠg‘å—¦
# j ‚ª‰æ–Ê�ʼnº•”‚É”z’u‚µ‚½Žž‚ÌŠg‘å—¦
# 1 ”{‚Æ‚µ‚½‚¢‚Æ‚«‚à�A1.0 ‚Æ•K‚¸�¬�”‚Å�Ý’è‚·‚邱‚Æ
speed = 150
@active = 1
@action = 2
@anime_wait = false
@damage_wait = 10
@enemy_speed = 40
@force = 2
@drive = true
@scroll_time = 15
@zoom_rate = [0.2, 1.0]
@help_time = 40
@escape == false
@camera = nil
@max = 0
@turn_cnt = 0
@help_wait = 0
@action_battlers = []
@synthe = []
@spell_p = {}
@spell_e = {}
@command_a = false
@command = []
@party = false
for battler in $game_party.actors + $game_troop.enemies
spell_reset(battler)
battler.at = battler.agi * rand(speed / 2)
battler.damage_pop = {}
battler.damage = {}
battler.damage_sp = {}
battler.critical = {}
battler.recover_hp = {}
battler.recover_sp = {}
battler.state_p = {}
battler.state_m = {}
battler.animation = []
if battler.is_a?(Game_Actor)
@max += battler.agi
end
end
@max *= speed
@max /= $game_party.actors.size
for battler in $game_party.actors + $game_troop.enemies
battler.atp = 100 * battler.at / @max
end
end
#--------------------------------------------------------------------------
# �œ ATƒQ�[ƒWMaxŽžSE
#--------------------------------------------------------------------------
def fullat_se
Audio.se_play("Audio/SE/033-switch02", 80, 100)
end
#--------------------------------------------------------------------------
# �œ ƒŒƒxƒ‹ƒAƒbƒvSE
#--------------------------------------------------------------------------
def levelup_se
Audio.se_play("Audio/SE/056-Right02", 80, 100)
end
#--------------------------------------------------------------------------
# �œ ƒXƒLƒ‹�K“¾SE
#--------------------------------------------------------------------------
def skill_se
Audio.se_play("Audio/SE/056-Right02", 80, 150)
end
end

class Window_Base < Window
#--------------------------------------------------------------------------
# �œ ATG ‚Ì•`‰æ
# actor : ƒAƒNƒ^�[
# x : •`‰æ�æ X �À•W
# y : •`‰æ�æ Y �À•W
# width : •`‰æ�æ‚Ì•�
#--------------------------------------------------------------------------
def draw_actor_atg(actor, x, y, width = 144)
if @at_gauge == nil
# plus_x:X�À•W‚̈ʒu•â�³ rate_x:X�À•W‚̈ʒu•â�³(%) plus_y:Y�À•W‚̈ʒu•â�³
# plus_width:•�‚Ì•â�³ rate_width:•�‚Ì•â�³(%) height:�c•�
# align1:•`‰æƒ^ƒCƒv1 0:�¶‹l‚ß 1:’†‰›‘µ‚¦ 2:‰E‹l‚ß
# align2:•`‰æƒ^ƒCƒv2 0:�ã‹l‚ß 1:’†‰›‘µ‚¦ 2:‰º‹l‚ß
# align3:ƒQ�[ƒWƒ^ƒCƒv 0:�¶‹l‚ß 1:‰E‹l‚ß
@plus_x = 0
@rate_x = 0
@plus_y = 16
@plus_width = 0
@rate_width = 100
@width = @plus_width + width * @rate_width / 100
@height = 16
@align1 = 0
@align2 = 1
@align3 = 0
# ƒOƒ‰ƒf�[ƒVƒ‡ƒ“�Ý’è grade1:‹óƒQ�[ƒW grade2:ŽÀƒQ�[ƒW
# (0:‰¡‚ɃOƒ‰ƒf�[ƒVƒ‡ƒ“ 1:�c‚ɃOƒ‰ƒf�[ƒVƒ‡ƒ“ 2:ŽÎ‚߂ɃOƒ‰ƒf�[ƒVƒ‡ƒ“�j
grade1 = 1
grade2 = 0
# �F�Ý’è�Bcolor1:�ÅŠO˜g�Ccolor2:’†˜g
# color3:‹ó˜gƒ_�[ƒNƒJƒ‰�[�Ccolor4:‹ó˜gƒ‰ƒCƒgƒJƒ‰�[
color1 = Color.new(0, 0, 0)
color2 = Color.new(255, 255, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 0, 64, 192)
# ƒQ�[ƒW‚Ì�F�Ý’è
# ’Ê�펞‚Ì�F�Ý’è
color5 = Color.new(0, 64, 80)
color6 = Color.new(0, 128, 160)
# ƒQ�[ƒW‚ªMAX‚ÌŽž‚Ì�F�Ý’è
color7 = Color.new(80, 0, 0)
color8 = Color.new(240, 0, 0)
# ˜AŒgƒXƒLƒ‹Žg—pŽž‚Ì�F�Ý’è
color9 = Color.new(80, 64, 32)
color10 = Color.new(240, 192, 96)
# ƒXƒLƒ‹‰r�¥Žž‚Ì�F�Ý’è
color11 = Color.new(80, 0, 64)
color12 = Color.new(240, 0, 192)
# ƒQ�[ƒW‚Ì•`‰æ
gauge_rect_at(@width, @height, @align3, color1, color2,
color3, color4, color5, color6, color7, color8,
color9, color10, color11, color12, grade1, grade2)
end
# •Ï�”at‚É•`‰æ‚·‚éƒQ�[ƒW‚Ì•�‚ð‘ã“ü
if actor.rtp == 0
at = (width + @plus_width) * actor.atp * @rate_width / 10000
else
at = (width + @plus_width) * actor.rt * @rate_width / actor.rtp / 100
end
if at > width
at = width
end
# ƒQ�[ƒW‚Ì�¶‹l�E’†‰›�\‚¦“™‚Ì•â�³
case @align1
when 1
x += (@rect_width - width) / 2
when 2
x += @rect_width - width
end
case @align2
when 1
y -= @height / 2
when 2
y -= @height
end
self.contents.blt(x + @plus_x + width * @rate_x / 100, y + @plus_y,
@at_gauge, Rect.new(0, 0, @width, @height))
if @align3 == 0
rect_x = 0
else
x += @width - at - 1
rect_x = @width - at - 1
end
# ƒQ�[ƒW‚Ì�F�Ý’è
if at == width
# MAXŽž‚̃Q�[ƒW•`‰æ
self.contents.blt(x + @plus_x + @width * @rate_x / 100, y + @plus_y,
@at_gauge, Rect.new(rect_x, @height * 2, at, @height))
else
if actor.rtp == 0
# ’Ê�펞‚̃Q�[ƒW•`‰æ
self.contents.blt(x + @plus_x + @width * @rate_x / 100, y + @plus_y,
@at_gauge, Rect.new(rect_x, @height, at, @height))
else
if actor.spell == true
# ˜AŒgƒXƒLƒ‹Žg—pŽž‚̃Q�[ƒW•`‰æ
self.contents.blt(x + @plus_x + @width * @rate_x / 100, y + @plus_y,
@at_gauge, Rect.new(rect_x, @height * 3, at, @height))
else
# ƒXƒLƒ‹‰r�¥Žž‚̃Q�[ƒW•`‰æ
self.contents.blt(x + @plus_x + @width * @rate_x / 100, y + @plus_y,
@at_gauge, Rect.new(rect_x, @height * 4, at, @height))
end
end
end
end
end

#==============================================================================
# �¡ Scene_Battle (•ªŠ„’è‹` 1)
#------------------------------------------------------------------------------
# �@ƒoƒgƒ‹‰æ–Ê‚Ì�ˆ—�‚ð�s‚¤ƒNƒ‰ƒX‚Å‚·�B
#==============================================================================

class Scene_Battle
#--------------------------------------------------------------------------
# �œ ƒ�ƒCƒ“�ˆ—�
#--------------------------------------------------------------------------
def main
# �퓬—p‚ÌŠeŽíˆêŽžƒf�[ƒ^‚ð�‰Šú‰»
$game_temp.in_battle = true
$game_temp.battle_turn = 0
$game_temp.battle_event_flags.clear
$game_temp.battle_abort = false
$game_temp.battle_main_phase = false
$game_temp.battleback_name = $game_map.battleback_name
$game_temp.forcing_battler = nil
# ƒoƒgƒ‹ƒCƒxƒ“ƒg—pƒCƒ“ƒ^ƒvƒŠƒ^‚ð�‰Šú‰»
$game_system.battle_interpreter.setup(nil, 0)
# ƒgƒ‹�[ƒv‚ð�€”õ
@troop_id = $game_temp.battle_troop_id
$game_troop.setup(@troop_id)
atb_setup
# ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚ð�ì�¬
s1 = $data_system.words.attack
s2 = $data_system.words.skill
s3 = $data_system.words.guard
s4 = $data_system.words.item
@actor_command_window = Window_Command.new(160, [s1, s2, s3, s4])
@actor_command_window.y = 160
@actor_command_window.back_opacity = 160
@actor_command_window.active = false
@actor_command_window.visible = false
# ‚»‚Ì‘¼‚̃EƒBƒ“ƒhƒE‚ð�ì�¬
@party_command_window = Window_PartyCommand.new
@help_window = Window_Help.new
@help_window.back_opacity = 160
@help_window.visible = false
@status_window = Window_BattleStatus.new
@message_window = Window_Message.new
# ƒXƒvƒ‰ƒCƒgƒZƒbƒg‚ð�ì�¬
@spriteset = Spriteset_Battle.new
# ƒEƒFƒCƒgƒJƒEƒ“ƒg‚ð�‰Šú‰»
@wait_count = 0
# ƒgƒ‰ƒ“ƒWƒVƒ‡ƒ“ŽÀ�s
if $data_system.battle_transition == ""
Graphics.transition(20)
else
Graphics.transition(40, "Graphics/Transitions/" +
$data_system.battle_transition)
end
# ƒvƒŒƒoƒgƒ‹ƒtƒF�[ƒYŠJŽn
start_phase1
# ƒ�ƒCƒ“ƒ‹�[ƒv
loop do
# ƒQ�[ƒ€‰æ–Ê‚ð�X�V
Graphics.update
# “ü—Í�î•ñ‚ð�X�V
Input.update
# ƒtƒŒ�[ƒ€�X�V
update
# ‰æ–Ê‚ª�Ø‚è‘Ö‚í‚Á‚½‚烋�[ƒv‚ð’†’f
if $scene != self
break
end
end
# ƒ}ƒbƒv‚ðƒŠƒtƒŒƒbƒVƒ…
$game_map.refresh
# ƒgƒ‰ƒ“ƒWƒVƒ‡ƒ“�€”õ
Graphics.freeze
# ƒEƒBƒ“ƒhƒE‚ð‰ð•ú
@actor_command_window.dispose
@party_command_window.dispose
@help_window.dispose
@status_window.dispose
@message_window.dispose
if @skill_window != nil
@skill_window.dispose
end
if @item_window != nil
@item_window.dispose
end
if @result_window != nil
@result_window.dispose
end
# ƒXƒvƒ‰ƒCƒgƒZƒbƒg‚ð‰ð•ú
@spriteset.dispose
# ƒ^ƒCƒgƒ‹‰æ–Ê‚É�Ø‚è‘Ö‚¦’†‚Ì�ê�‡
if $scene.is_a?(Scene_Title)
# ‰æ–Ê‚ðƒtƒF�[ƒhƒAƒEƒg
Graphics.transition
Graphics.freeze
end
# �퓬ƒeƒXƒg‚©‚çƒQ�[ƒ€ƒI�[ƒo�[‰æ–ʈȊO‚É�Ø‚è‘Ö‚¦’†‚Ì�ê�‡
if $BTEST and not $scene.is_a?(Scene_Gameover)
$scene = nil
end
end
#--------------------------------------------------------------------------
# �œ �Ÿ”s”»’è
#--------------------------------------------------------------------------
def judge
# ‘S–Å”»’肪�^�A‚Ü‚½‚̓p�[ƒeƒB�l�”‚ª 0 �l‚Ì�ê�‡
if $game_party.all_dead? or $game_party.actors.size == 0
# ”s–k‰Â”\‚Ì�ê�‡
if $game_temp.battle_can_lose
# ƒoƒgƒ‹ŠJŽn‘O‚Ì BGM ‚É–ß‚·
$game_system.bgm_play($game_temp.map_bgm)
# ƒoƒgƒ‹�I—¹
battle_end(2)
# true ‚ð•Ô‚·
return true
end
# ƒQ�[ƒ€ƒI�[ƒo�[ƒtƒ‰ƒO‚ðƒZƒbƒg
$game_temp.gameover = true
# true ‚ð•Ô‚·
return true
end
# ƒGƒlƒ~�[‚ª 1 ‘Ì‚Å‚à‘¶�Ý‚·‚ê‚Î false ‚ð•Ô‚·
for enemy in $game_troop.enemies
if enemy.exist?
return false
end
end
# ƒAƒtƒ^�[ƒoƒgƒ‹ƒtƒF�[ƒYŠJŽn (�Ÿ—˜)
start_phase5
# true ‚ð•Ô‚·
return true
end

 #--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V
#--------------------------------------------------------------------------
def update
# ƒoƒgƒ‹ƒCƒxƒ“ƒgŽÀ�s’†‚Ì�ê�‡
if $game_system.battle_interpreter.running?
if @command.size > 0
@command_a = false
@command = []
command_delete
end
@status_window.at_refresh
# ƒCƒ“ƒ^ƒvƒŠƒ^‚ð�X�V
$game_system.battle_interpreter.update
# ƒAƒNƒVƒ‡ƒ“‚ð‹­�§‚³‚ê‚Ä‚¢‚éƒoƒgƒ‰�[‚ª‘¶�Ý‚µ‚È‚¢�ê�‡
if $game_temp.forcing_battler == nil
# ƒoƒgƒ‹ƒCƒxƒ“ƒg‚ÌŽÀ�s‚ª�I‚í‚Á‚½�ê�‡
unless $game_system.battle_interpreter.running?
# ƒoƒgƒ‹ƒCƒxƒ“ƒg‚̃ZƒbƒgƒAƒbƒv‚ð�ÄŽÀ�s
@status_window.refresh
setup_battle_event
end
end
end
# ƒVƒXƒeƒ€ (ƒ^ƒCƒ}�[)�A‰æ–Ê‚ð�X�V
$game_system.update
$game_screen.update
# ƒ^ƒCƒ}�[‚ª 0 ‚É‚È‚Á‚½�ê�‡
if $game_system.timer_working and $game_system.timer == 0
# ƒoƒgƒ‹’†’f
$game_temp.battle_abort = true
end
# ƒEƒBƒ“ƒhƒE‚ð�X�V
@help_window.update
@party_command_window.update
@actor_command_window.update
@status_window.update
@message_window.update
# ƒXƒvƒ‰ƒCƒgƒZƒbƒg‚ð�X�V
@spriteset.update
# ƒgƒ‰ƒ“ƒWƒVƒ‡ƒ“�ˆ—�’†‚Ì�ê�‡
if $game_temp.transition_processing
# ƒgƒ‰ƒ“ƒWƒVƒ‡ƒ“�ˆ—�’†ƒtƒ‰ƒO‚ðƒNƒŠƒA
$game_temp.transition_processing = false
# ƒgƒ‰ƒ“ƒWƒVƒ‡ƒ“ŽÀ�s
if $game_temp.transition_name == ""
Graphics.transition(20)
else
Graphics.transition(40, "Graphics/Transitions/" +
$game_temp.transition_name)
end
end
# ƒ�ƒbƒZ�[ƒWƒEƒBƒ“ƒhƒE•\Ž¦’†‚Ì�ê�‡
if $game_temp.message_window_showing
return
end
# ƒQ�[ƒ€ƒI�[ƒo�[‚Ì�ê�‡
if $game_temp.gameover
# ƒQ�[ƒ€ƒI�[ƒo�[‰æ–Ê‚É�Ø‚è‘Ö‚¦
$scene = Scene_Gameover.new
return
end
# ƒ^ƒCƒgƒ‹‰æ–Ê‚É–ß‚·�ê�‡
if $game_temp.to_title
# ƒ^ƒCƒgƒ‹‰æ–Ê‚É�Ø‚è‘Ö‚¦
$scene = Scene_Title.new
return
end
# ƒoƒgƒ‹’†’f‚Ì�ê�‡
if $game_temp.battle_abort
# ƒoƒgƒ‹ŠJŽn‘O‚Ì BGM ‚É–ß‚·
$game_system.bgm_play($game_temp.map_bgm)
# ƒoƒgƒ‹�I—¹
battle_end(1)
return
end
# ƒwƒ‹ƒvƒEƒBƒ“ƒhƒE•\Ž¦’†‚Ì�ê�‡
if @help_wait > 0
@help_wait -= 1
if @help_wait == 0
# ƒwƒ‹ƒvƒEƒBƒ“ƒhƒE‚ð‰B‚·
@help_window.visible = false
end
end
# ƒtƒF�[ƒY‚É‚æ‚Á‚Ä•ªŠò
case @phase
when 0 # ATƒQ�[ƒW�X�VƒtƒF�[ƒY
if anime_wait_return
update_phase0
end
when 1 # ƒvƒŒƒoƒgƒ‹ƒtƒF�[ƒY
update_phase1
return
when 2 # ƒp�[ƒeƒBƒRƒ}ƒ“ƒhƒtƒF�[ƒY
update_phase2
return
when 5 # ƒAƒtƒ^�[ƒoƒgƒ‹ƒtƒF�[ƒY
update_phase5
return
end
if $scene != self
return
end
if @phase == 0
if @command.size != 0 # ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒtƒF�[ƒY
if @command_a == false
start_phase3
end
update_phase3
end
# ƒEƒFƒCƒg’†‚Ì�ê�‡
if @wait_count > 0
# ƒEƒFƒCƒgƒJƒEƒ“ƒg‚ðŒ¸‚ç‚·
@wait_count -= 1
return
end
update_phase4
end
end

#==============================================================================
# �¡ Scene_Battle (•ªŠ„’è‹` 2)
#------------------------------------------------------------------------------
# �@ƒoƒgƒ‹‰æ–Ê‚Ì�ˆ—�‚ð�s‚¤ƒNƒ‰ƒX‚Å‚·�B
#==============================================================================

#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V (ATƒQ�[ƒW�X�VƒtƒF�[ƒY)
#--------------------------------------------------------------------------
def update_phase0
if $game_temp.battle_turn == 0
$game_temp.battle_turn = 1
end
# B ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ�ê�‡
if @command_a == false and @party == false
if Input.trigger?(Input::B)
# ƒLƒƒƒ“ƒZƒ‹ SE ‚ð‰‰‘t
$game_system.se_play($data_system.cancel_se)
@party = true
end
end
if @party == true and
((@action > 0 and @action_battlers.empty?) or (@action == 0 and
(@action_battlers.empty? or @action_battlers[0].phase == 1)))
# ƒp�[ƒeƒBƒRƒ}ƒ“ƒhƒtƒF�[ƒY‚Ö
start_phase2
return
end
# ATƒQ�[ƒW‘�‰Á�ˆ—�
cnt = 0
for battler in $game_party.actors + $game_troop.enemies
active?(battler)
if battler.rtp == 0
if battler.at >= @max
if battler.is_a?(Game_Actor)
if battler.inputable?
unless @action_battlers.include?(battler) or
@command.include?(battler) or @escape == true
if battler.current_action.forcing
fullat_se
force_action(battler)
action_start(battler)
else
fullat_se
@command.push(battler)
end
end
else
unless @action_battlers.include?(battler) or
battler == @command[0]
battler.current_action.clear
if @command.include?(battler)
@command.delete(battler)
else
if battler.movable?
fullat_se
end
end
action_start(battler)
end
end
else
unless @action_battlers.include?(battler)
if battler.current_action.forcing
force_action(battler)
action_start(battler)
else
if @enemy_speed != 0
if rand(@enemy_speed) == 0
number = cnt - $game_party.actors.size
enemy_action(number)
end
else
number = cnt - $game_party.actors.size
enemy_action(number)
end
end
end
end
else
battler.at += battler.agi
if battler.guarding?
battler.at += battler.agi
end
if battler.movable?
battler.atp = 100 * battler.at / @max
end
end
else
if battler.rt >= battler.rtp
speller = synthe?(battler)
if speller != nil
battler = speller[0]
end
unless @action_battlers.include?(battler)
if battler.is_a?(Game_Actor)
fullat_se
end
battler.rt = battler.rtp
action_start(battler)
end
else
battler.rt += battler.agi
speller = synthe?(battler)
if speller != nil
for spell in speller
if spell != battler
spell.rt += battler.agi
end
end
end
end
end
cnt += 1
end
# ATƒQ�[ƒW‚ðƒŠƒtƒŒƒbƒVƒ…
@status_window.at_refresh
# “¦‘–�ˆ—�
if @escape == true and
((@action > 0 and @action_battlers.empty?) or (@action == 0 and
(@action_battlers.empty? or @action_battlers[0].phase == 1)))
temp = false
for battler in $game_party.actors
if battler.inputable?
temp = true
end
end
if temp == true
for battler in $game_party.actors
if battler.at < @max and battler.inputable?
temp = false
break
end
end
if temp == true
@escape = false
for battler in $game_party.actors
battler.at %= @max
end
$game_temp.battle_main_phase = false
update_phase2_escape
end
end
end
end
#--------------------------------------------------------------------------
# �œ ƒp�[ƒeƒBƒRƒ}ƒ“ƒhƒtƒF�[ƒYŠJŽn
#--------------------------------------------------------------------------
def start_phase2
# ƒtƒF�[ƒY 2 ‚ɈÚ�s
@phase = 2
@party = false
# ƒp�[ƒeƒBƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚ð—LŒø‰»
@party_command_window.active = true
@party_command_window.visible = true
# ƒAƒNƒ^�[‚ð”ñ‘I‘ð�ó‘Ô‚É�Ý’è
@actor_index = -1
# ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚𖳌ø‰»
@actor_command_window.active = false
@actor_command_window.visible = false
if @command.size != 0
# ƒAƒNƒ^�[‚Ì–¾–ŃGƒtƒFƒNƒg OFF
if @active_actor != nil
@active_actor.blink = false
end
end
# ƒJƒ�ƒ‰ƒZƒbƒg
@camera == "party"
@spriteset.screen_target(0, 0, 1)
# ƒ�ƒCƒ“ƒtƒF�[ƒYƒtƒ‰ƒO‚ðƒNƒŠƒA
$game_temp.battle_main_phase = false
end
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V (ƒp�[ƒeƒBƒRƒ}ƒ“ƒhƒtƒF�[ƒY)
#--------------------------------------------------------------------------
def update_phase2
# C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ�ê�‡
if Input.trigger?(Input::C)
# ƒp�[ƒeƒBƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚̃J�[ƒ\ƒ‹ˆÊ’u‚Å•ªŠò
case @party_command_window.index
when 0 # �키
# ƒp�[ƒeƒBƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚𖳌ø‰»
@party_command_window.active = false
@party_command_window.visible = false
# Œˆ’è SE ‚ð‰‰‘t
$game_system.se_play($data_system.decision_se)
@escape = false
@phase = 0
if $game_temp.battle_turn == 0
$game_temp.battle_turn = 1
end
if @command_a == true
# ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒtƒF�[ƒYŠJŽn
start_phase3
else
$game_temp.battle_main_phase = true
end
when 1 # “¦‚°‚é
# “¦‘–‰Â”\‚Å‚Í‚È‚¢�ê�‡
if $game_temp.battle_can_escape == false
# ƒuƒU�[ SE ‚ð‰‰‘t
$game_system.se_play($data_system.buzzer_se)
return
end
# Œˆ’è SE ‚ð‰‰‘t
$game_system.se_play($data_system.decision_se)
@phase = 0
# ƒp�[ƒeƒBƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚𖳌ø‰»
@party_command_window.active = false
@party_command_window.visible = false
$game_temp.battle_main_phase = true
if $game_temp.battle_turn == 0
update_phase2_escape
$game_temp.battle_turn = 1
for battler in $game_party.actors
battler.at -= @max / 2
end
return
end
# Œˆ’è SE ‚ð‰‰‘t
$game_system.se_play($data_system.decision_se)
@escape = true
for battler in $game_party.actors
@command_a = false
@command.delete(battler)
@action_battlers.delete(battler)
skill_reset(battler)
end
end
return
end
end
#--------------------------------------------------------------------------
# �œ ƒAƒtƒ^�[ƒoƒgƒ‹ƒtƒF�[ƒYŠJŽn
#--------------------------------------------------------------------------
def start_phase5
# ƒtƒF�[ƒY 5 ‚ɈÚ�s
@phase = 5
# ƒoƒgƒ‹�I—¹ ME ‚ð‰‰‘t
$game_system.me_play($game_system.battle_end_me)
# ƒoƒgƒ‹ŠJŽn‘O‚Ì BGM ‚É–ß‚·
$game_system.bgm_play($game_temp.map_bgm)
# EXP�AƒS�[ƒ‹ƒh�AƒgƒŒƒWƒƒ�[‚ð�‰Šú‰»
exp = 0
gold = 0
treasures = []
if @active_actor != nil
@active_actor.blink = false
end
# ƒ�ƒCƒ“ƒtƒF�[ƒYƒtƒ‰ƒO‚ðƒZƒbƒg
$game_temp.battle_main_phase = true
# ƒp�[ƒeƒBƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚𖳌ø‰»
@party_command_window.active = false
@party_command_window.visible = false
# ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚𖳌ø‰»
@actor_command_window.active = false
@actor_command_window.visible = false
if @skill_window != nil
# ƒXƒLƒ‹ƒEƒBƒ“ƒhƒE‚ð‰ð•ú
@skill_window.dispose
@skill_window = nil
end
if @item_window != nil
# ƒAƒCƒeƒ€ƒEƒBƒ“ƒhƒE‚ð‰ð•ú
@item_window.dispose
@item_window = nil
end
# ƒwƒ‹ƒvƒEƒBƒ“ƒhƒE‚ð‰B‚·
@help_window.visible = false
# ƒ‹�[ƒv
for enemy in $game_troop.enemies
# ƒGƒlƒ~�[‚ª‰B‚ê�ó‘Ô‚Å‚È‚¢�ê�‡
unless enemy.hidden
# Šl“¾ EXP�AƒS�[ƒ‹ƒh‚ð’ljÁ
exp += enemy.exp
gold += enemy.gold
# ƒgƒŒƒWƒƒ�[�oŒ»”»’è
if rand(100) < enemy.treasure_prob
if enemy.item_id > 0
treasures.push($data_items[enemy.item_id])
end
if enemy.weapon_id > 0
treasures.push($data_weapons[enemy.weapon_id])
end
if enemy.armor_id > 0
treasures.push($data_armors[enemy.armor_id])
end
end
end
end
# ƒgƒŒƒWƒƒ�[‚Ì�”‚ð 6 ŒÂ‚Ü‚Å‚ÉŒÀ’è
treasures = treasures[0..5]
# EXP Šl“¾
for i in 0...$game_party.actors.size
actor = $game_party.actors[i]
if actor.cant_get_exp? == false
last_level = actor.level
actor.exp += exp
if actor.level > last_level
@status_window.level_up(i)
actor.damage[[actor, -1]] = "Level up!"
actor.up_level = actor.level - last_level
end
end
end
# ƒS�[ƒ‹ƒhŠl“¾
$game_party.gain_gold(gold)
# ƒgƒŒƒWƒƒ�[Šl“¾
for item in treasures
case item
when RPG::Item
$game_party.gain_item(item.id, 1)
when RPG::Weapon
$game_party.gain_weapon(item.id, 1)
when RPG::Armor
$game_party.gain_armor(item.id, 1)
end
end
# ƒoƒgƒ‹ƒŠƒUƒ‹ƒgƒEƒBƒ“ƒhƒE‚ð�ì�¬
@result_window = Window_BattleResult.new(exp, gold, treasures)
# ƒEƒFƒCƒgƒJƒEƒ“ƒg‚ð�Ý’è
@phase5_wait_count = 100
end
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V (ƒAƒtƒ^�[ƒoƒgƒ‹ƒtƒF�[ƒY)
#--------------------------------------------------------------------------
def update_phase5
# ƒEƒFƒCƒgƒJƒEƒ“ƒg‚ª 0 ‚æ‚è‘å‚«‚¢�ê�‡
if @phase5_wait_count > 0
# ƒEƒFƒCƒgƒJƒEƒ“ƒg‚ðŒ¸‚ç‚·
@phase5_wait_count -= 1
# ƒEƒFƒCƒgƒJƒEƒ“ƒg‚ª 0 ‚É‚È‚Á‚½�ê�‡
if @phase5_wait_count == 0
# ƒŠƒUƒ‹ƒgƒEƒBƒ“ƒhƒE‚ð•\Ž¦
@result_window.visible = true
# ƒ�ƒCƒ“ƒtƒF�[ƒYƒtƒ‰ƒO‚ðƒNƒŠƒA
$game_temp.battle_main_phase = false
# ƒXƒe�[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðƒŠƒtƒŒƒbƒVƒ…
@status_window.refresh
for actor in $game_party.actors
if actor.damage.include?([actor, 0])
@phase5_wait_count = 20
actor.damage_pop[[actor, 0]] = true
end
if actor.damage.include?([actor, -1])
@phase5_wait_count = 20
actor.damage_pop[[actor, -1]] = true
for level in actor.level - actor.up_level + 1..actor.level
for skill in $data_classes[actor.class_id].learnings
if level == skill.level and not actor.skill_learn?(skill.id)
actor.damage[[actor, 0]] = "New Skill!"
break
end
end
end
end
end
end
return
end
# C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ�ê�‡
if Input.trigger?(Input::C)
# ƒoƒgƒ‹�I—¹
battle_end(0)
end
end

#==============================================================================
# �¡ Scene_Battle (•ªŠ„’è‹` 3)
#------------------------------------------------------------------------------
# �@ƒoƒgƒ‹‰æ–Ê‚Ì�ˆ—�‚ð�s‚¤ƒNƒ‰ƒX‚Å‚·�B
#==============================================================================

#--------------------------------------------------------------------------
# �œ ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒtƒF�[ƒYŠJŽn
#--------------------------------------------------------------------------
def start_phase3
# ƒ�ƒCƒ“ƒtƒF�[ƒYƒtƒ‰ƒO‚ðƒNƒŠƒA
$game_temp.battle_main_phase = false
@command_a = true
@active_actor = @command[0]
cnt = 0
for actor in $game_party.actors
if actor == @active_actor
@actor_index = cnt
end
cnt += 1
end
@active_actor.blink = true
unless @active_actor.inputable?
@active_actor.current_action.clear
phase3_next_actor
return
end
phase3_setup_command_window
# ƒJƒ�ƒ‰‚Ì�Ý’è
@camera = "command"
plus = ($game_party.actors.size - 1) / 2.0 - @actor_index
y = [(plus.abs - 1.5) * 10 , 0].min
@spriteset.screen_target(plus * 50, y, 1.0 + y * 0.002)
end
#--------------------------------------------------------------------------
# �œ ƒAƒNƒ^�[‚̃Rƒ}ƒ“ƒh“ü—Í�I—¹
#--------------------------------------------------------------------------
def phase3_next_actor
@command.shift
@command_a = false
# ƒ�ƒCƒ“ƒtƒF�[ƒYƒtƒ‰ƒO‚ðƒZƒbƒg
$game_temp.battle_main_phase = true
# ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚𖳌ø‰»
@actor_command_window.active = false
@actor_command_window.visible = false
# ƒAƒNƒ^�[‚Ì–¾–ŃGƒtƒFƒNƒg OFF
if @active_actor != nil
@active_actor.blink = false
end
action_start(@active_actor)
# ƒJƒ�ƒ‰‚ðŒ³‚É–ß‚·
if @camera == "command"
@spriteset.screen_target(0, 0, 1)
end
return
end

 #--------------------------------------------------------------------------
# �œ ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚̃ZƒbƒgƒAƒbƒv
#--------------------------------------------------------------------------
def phase3_setup_command_window
# ƒp�[ƒeƒBƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚𖳌ø‰»
@party_command_window.active = false
@party_command_window.visible = false
# ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚ð—LŒø‰»
@actor_command_window.active = true
@actor_command_window.visible = true
# ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚̈ʒu‚ð�Ý’è
@actor_command_window.x = @actor_index * 160 +
(4 - $game_party.actors.size) * 80
# ƒCƒ“ƒfƒbƒNƒX‚ð 0 ‚É�Ý’è
@actor_command_window.index = 0
end
#--------------------------------------------------------------------------
# �œ ƒGƒlƒ~�[ƒAƒNƒVƒ‡ƒ“�ì�¬
#--------------------------------------------------------------------------
def enemy_action(number)
enemy = $game_troop.enemies[number]
unless enemy.current_action.forcing
enemy.make_action
end
action_start(enemy)
end
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V (ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒtƒF�[ƒY : Šî–{ƒRƒ}ƒ“ƒh)
#--------------------------------------------------------------------------
def update_phase3_basic_command
unless @active_actor.inputable?
@active_actor.current_action.clear
phase3_next_actor
return
end
# B ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ�ê�‡
if Input.trigger?(Input::B) and @party == false
# ƒLƒƒƒ“ƒZƒ‹ SE ‚ð‰‰‘t
$game_system.se_play($data_system.cancel_se)
@party = true
end
if @party == true and
((@action > 0 and @action_battlers.empty?) or (@action == 0 and
(@action_battlers.empty? or @action_battlers[0].phase == 1)))
# ƒp�[ƒeƒBƒRƒ}ƒ“ƒhƒtƒF�[ƒY‚Ö
start_phase2
return
end
# C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ�ê�‡
if Input.trigger?(Input::C)
@party = false
# ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚̃J�[ƒ\ƒ‹ˆÊ’u‚Å•ªŠò
case @actor_command_window.index
when 0 # �UŒ‚
if victory?
# ƒuƒU�[ SE ‚ð‰‰‘t
$game_system.se_play($data_system.buzzer_se)
return
end
# Œˆ’è SE ‚ð‰‰‘t
$game_system.se_play($data_system.decision_se)
# ƒGƒlƒ~�[‚Ì‘I‘ð‚ðŠJŽn
start_enemy_select
when 1 # ƒXƒLƒ‹
# Œˆ’è SE ‚ð‰‰‘t
$game_system.se_play($data_system.decision_se)
# ƒXƒLƒ‹‚Ì‘I‘ð‚ðŠJŽn
start_skill_select
when 2 # –hŒä
# Œˆ’è SE ‚ð‰‰‘t
$game_system.se_play($data_system.decision_se)
# ƒAƒNƒVƒ‡ƒ“‚ð�Ý’è
@active_actor.current_action.kind = 0
@active_actor.current_action.basic = 1
# ŽŸ‚̃AƒNƒ^�[‚̃Rƒ}ƒ“ƒh“ü—Í‚Ö
phase3_next_actor
when 3 # ƒAƒCƒeƒ€
# Œˆ’è SE ‚ð‰‰‘t
$game_system.se_play($data_system.decision_se)
# ƒAƒCƒeƒ€‚Ì‘I‘ð‚ðŠJŽn
start_item_select
end
return
end
# R ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ�ê�‡
if Input.trigger?(Input::R)
$game_system.se_play($data_system.cursor_se)
@party = false
# ƒAƒNƒ^�[‚Ì–¾–ŃGƒtƒFƒNƒg OFF
if @active_actor != nil
@active_actor.blink = false
end
@command.push(@command[0])
@command.shift
@command_a = false
# ƒ�ƒCƒ“ƒtƒF�[ƒYƒtƒ‰ƒO‚ðƒZƒbƒg
$game_temp.battle_main_phase = true
# ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚𖳌ø‰»
@actor_command_window.active = false
@actor_command_window.visible = false
end
# L ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ�ê�‡
if Input.trigger?(Input::L)
$game_system.se_play($data_system.cursor_se)
@party = false
# ƒAƒNƒ^�[‚Ì–¾–ŃGƒtƒFƒNƒg OFF
if @active_actor != nil
@active_actor.blink = false
end
@command.unshift(@command[@command.size - 1])
@command.delete_at(@command.size - 1)
@command_a = false
# ƒ�ƒCƒ“ƒtƒF�[ƒYƒtƒ‰ƒO‚ðƒZƒbƒg
$game_temp.battle_main_phase = true
# ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚𖳌ø‰»
@actor_command_window.active = false
@actor_command_window.visible = false
end
# ‰E ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ�ê�‡
if Input.trigger?(Input::RIGHT)
$game_system.se_play($data_system.cursor_se)
@party = false
# ƒAƒNƒ^�[‚Ì–¾–ŃGƒtƒFƒNƒg OFF
if @active_actor != nil
@active_actor.blink = false
end
actor = $game_party.actors[@actor_index]
while actor == @command[0] or (not @command.include?(actor))
@actor_index += 1
@actor_index %= $game_party.actors.size
actor = $game_party.actors[@actor_index]
if actor == @command[0]
break
end
end
while actor != @command[0]
@command.push(@command.shift)
end
@command_a = false
# ƒ�ƒCƒ“ƒtƒF�[ƒYƒtƒ‰ƒO‚ðƒZƒbƒg
$game_temp.battle_main_phase = true
# ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚𖳌ø‰»
@actor_command_window.active = false
@actor_command_window.visible = false
end
# �¶ ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ�ê�‡
if Input.trigger?(Input::LEFT)
$game_system.se_play($data_system.cursor_se)
@party = false
# ƒAƒNƒ^�[‚Ì–¾–ŃGƒtƒFƒNƒg OFF
if @active_actor != nil
@active_actor.blink = false
end
actor = $game_party.actors[@actor_index]
while actor == @command[0] or (not @command.include?(actor))
@actor_index -= 1
@actor_index %= $game_party.actors.size
actor = $game_party.actors[@actor_index]
if actor == @command[0]
break
end
end
while actor != @command[0]
@command.push(@command.shift)
end
@command_a = false
# ƒ�ƒCƒ“ƒtƒF�[ƒYƒtƒ‰ƒO‚ðƒZƒbƒg
$game_temp.battle_main_phase = true
# ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚𖳌ø‰»
@actor_command_window.active = false
@actor_command_window.visible = false
end
end
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V (ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒtƒF�[ƒY : ƒXƒLƒ‹‘I‘ð)
#--------------------------------------------------------------------------
def update_phase3_skill_select
# ƒRƒ}ƒ“ƒh‘I‘𒆂É�s“®•s”\‚É‚È‚Á‚½�ê�‡
unless @active_actor.inputable?
@active_actor.current_action.clear
command_delete
# ŽŸ‚̃AƒNƒ^�[‚̃Rƒ}ƒ“ƒh“ü—Í‚Ö
phase3_next_actor
return
end
# ƒXƒLƒ‹ƒEƒBƒ“ƒhƒE‚ð‰ÂŽ‹�ó‘Ô‚É‚·‚é
@skill_window.visible = true
# ƒXƒLƒ‹ƒEƒBƒ“ƒhƒE‚ð�X�V
@skill_window.update
# B ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ�ê�‡
if Input.trigger?(Input::B)
# ƒLƒƒƒ“ƒZƒ‹ SE ‚ð‰‰‘t
$game_system.se_play($data_system.cancel_se)
# ƒXƒLƒ‹‚Ì‘I‘ð‚ð�I—¹
end_skill_select
return
end
# C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ�ê�‡
if Input.trigger?(Input::C)
# ƒXƒLƒ‹ƒEƒBƒ“ƒhƒE‚ÅŒ»�Ý‘I‘ð‚³‚ê‚Ä‚¢‚éƒf�[ƒ^‚ðŽæ“¾
@skill = @skill_window.skill
# Žg—p‚Å‚«‚È‚¢�ê�‡
if @skill == nil or not @active_actor.skill_can_use?(@skill.id)
# ƒuƒU�[ SE ‚ð‰‰‘t
$game_system.se_play($data_system.buzzer_se)
return
end
if @skill.scope == 1 or @skill.scope == 2
if victory?
# ƒuƒU�[ SE ‚ð‰‰‘t
$game_system.se_play($data_system.buzzer_se)
return
end
end
# Œˆ’è SE ‚ð‰‰‘t
$game_system.se_play($data_system.decision_se)
# ƒAƒNƒVƒ‡ƒ“‚ð�Ý’è
@active_actor.current_action.skill_id = @skill.id
# ƒXƒLƒ‹ƒEƒBƒ“ƒhƒE‚ð•s‰ÂŽ‹�ó‘Ô‚É‚·‚é
@skill_window.visible = false
# Œø‰Ê”͈͂ª“G’P‘Ì‚Ì�ê�‡
if @skill.scope == 1
# ƒGƒlƒ~�[‚Ì‘I‘ð‚ðŠJŽn
start_enemy_select
# Œø‰Ê”͈͂ª–¡•û’P‘Ì‚Ì�ê�‡
elsif @skill.scope == 3 or @skill.scope == 5
# ƒAƒNƒ^�[‚Ì‘I‘ð‚ðŠJŽn
start_actor_select
# Œø‰Ê”͈͂ª’P‘Ì‚Å‚Í‚È‚¢�ê�‡
else
# ƒAƒNƒVƒ‡ƒ“‚ð�Ý’è
@active_actor.current_action.kind = 1
# ƒXƒLƒ‹‚Ì‘I‘ð‚ð�I—¹
end_skill_select
# ŽŸ‚̃AƒNƒ^�[‚̃Rƒ}ƒ“ƒh“ü—Í‚Ö
phase3_next_actor
end
return
end
end
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V (ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒtƒF�[ƒY : ƒAƒCƒeƒ€‘I‘ð)
#--------------------------------------------------------------------------
def update_phase3_item_select
# ƒRƒ}ƒ“ƒh‘I‘𒆂É�s“®•s”\‚É‚È‚Á‚½�ê�‡
unless @active_actor.inputable?
@active_actor.current_action.clear
command_delete
# ŽŸ‚̃AƒNƒ^�[‚̃Rƒ}ƒ“ƒh“ü—Í‚Ö
phase3_next_actor
return
end
# ƒAƒCƒeƒ€ƒEƒBƒ“ƒhƒE‚ð‰ÂŽ‹�ó‘Ô‚É‚·‚é
@item_window.visible = true
# ƒAƒCƒeƒ€ƒEƒBƒ“ƒhƒE‚ð�X�V
@item_window.update
# B ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ�ê�‡
if Input.trigger?(Input::B)
# ƒLƒƒƒ“ƒZƒ‹ SE ‚ð‰‰‘t
$game_system.se_play($data_system.cancel_se)
# ƒAƒCƒeƒ€‚Ì‘I‘ð‚ð�I—¹
end_item_select
return
end
# C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ�ê�‡
if Input.trigger?(Input::C)
# ƒAƒCƒeƒ€ƒEƒBƒ“ƒhƒE‚ÅŒ»�Ý‘I‘ð‚³‚ê‚Ä‚¢‚éƒf�[ƒ^‚ðŽæ“¾
@item = @item_window.item
# Žg—p‚Å‚«‚È‚¢�ê�‡
unless $game_party.item_can_use?(@item.id)
# ƒuƒU�[ SE ‚ð‰‰‘t
$game_system.se_play($data_system.buzzer_se)
return
end
if @item.scope == 1 or @item.scope == 2
if victory?
# ƒuƒU�[ SE ‚ð‰‰‘t
$game_system.se_play($data_system.buzzer_se)
return
end
end
# Œˆ’è SE ‚ð‰‰‘t
$game_system.se_play($data_system.decision_se)
# ƒAƒNƒVƒ‡ƒ“‚ð�Ý’è
@active_actor.current_action.item_id = @item.id
# ƒAƒCƒeƒ€ƒEƒBƒ“ƒhƒE‚ð•s‰ÂŽ‹�ó‘Ô‚É‚·‚é
@item_window.visible = false
# Œø‰Ê”͈͂ª“G’P‘Ì‚Ì�ê�‡
if @item.scope == 1
# ƒGƒlƒ~�[‚Ì‘I‘ð‚ðŠJŽn
start_enemy_select
# Œø‰Ê”͈͂ª–¡•û’P‘Ì‚Ì�ê�‡
elsif @item.scope == 3 or @item.scope == 5
# ƒAƒNƒ^�[‚Ì‘I‘ð‚ðŠJŽn
start_actor_select
# Œø‰Ê”͈͂ª’P‘Ì‚Å‚Í‚È‚¢�ê�‡
else
# ƒAƒNƒVƒ‡ƒ“‚ð�Ý’è
@active_actor.current_action.kind = 2
# ƒAƒCƒeƒ€‚Ì‘I‘ð‚ð�I—¹
end_item_select
# ŽŸ‚̃AƒNƒ^�[‚̃Rƒ}ƒ“ƒh“ü—Í‚Ö
phase3_next_actor
end
return
end
end
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V (ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒtƒF�[ƒY : ƒGƒlƒ~�[‘I‘ð)
#--------------------------------------------------------------------------
def update_phase3_enemy_select
if victory?
# ƒJƒ�ƒ‰‚ðŒ³‚É–ß‚·
if @camera == "select"
@spriteset.screen_target(0, 0, 1)
end
# ƒGƒlƒ~�[‚Ì‘I‘ð‚ð�I—¹
end_enemy_select
return
end
# ƒRƒ}ƒ“ƒh‘I‘𒆂É�s“®•s”\‚É‚È‚Á‚½�ê�‡
unless @active_actor.inputable?
# ƒJƒ�ƒ‰‚ðŒ³‚É–ß‚·
if @camera == "select"
@spriteset.screen_target(0, 0, 1)
end
@active_actor.current_action.clear
command_delete
# ŽŸ‚̃AƒNƒ^�[‚̃Rƒ}ƒ“ƒh“ü—Í‚Ö
phase3_next_actor
return
end
# ƒGƒlƒ~�[ƒAƒ��[‚ð�X�V
@enemy_arrow.update
# B ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ�ê�‡
if Input.trigger?(Input::B)
# ƒLƒƒƒ“ƒZƒ‹ SE ‚ð‰‰‘t
$game_system.se_play($data_system.cancel_se)
# ƒJƒ�ƒ‰‚ðŒ³‚É–ß‚·
if @camera == "select"
# ƒJƒ�ƒ‰‚Ì�Ý’è
@camera = "command"
plus = ($game_party.actors.size - 1) / 2.0 - @actor_index
y = [(plus.abs - 1.5) * 10 , 0].min
@spriteset.screen_target(plus * 50, y, 1.0 + y * 0.002)
end
# ƒGƒlƒ~�[‚Ì‘I‘ð‚ð�I—¹
end_enemy_select
return
end
# C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ�ê�‡
if Input.trigger?(Input::C)
# Œˆ’è SE ‚ð‰‰‘t
$game_system.se_play($data_system.decision_se)
# ƒAƒNƒVƒ‡ƒ“‚ð�Ý’è
@active_actor.current_action.kind = 0
@active_actor.current_action.basic = 0
@active_actor.current_action.target_index = @enemy_arrow.index
# ƒXƒLƒ‹ƒEƒBƒ“ƒhƒE•\Ž¦’†‚Ì�ê�‡
if @skill_window != nil
# ƒAƒNƒVƒ‡ƒ“‚ð�Ä�Ý’è
@active_actor.current_action.kind = 1
# ƒXƒLƒ‹‚Ì‘I‘ð‚ð�I—¹
end_skill_select
end
# ƒAƒCƒeƒ€ƒEƒBƒ“ƒhƒE•\Ž¦’†‚Ì�ê�‡
if @item_window != nil
# ƒAƒNƒVƒ‡ƒ“‚ð�Ä�Ý’è
@active_actor.current_action.kind = 2
# ƒAƒCƒeƒ€‚Ì‘I‘ð‚ð�I—¹
end_item_select
end
# ƒGƒlƒ~�[‚Ì‘I‘ð‚ð�I—¹
end_enemy_select
# ŽŸ‚̃AƒNƒ^�[‚̃Rƒ}ƒ“ƒh“ü—Í‚Ö
phase3_next_actor
end
end
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V (ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒtƒF�[ƒY : ƒAƒNƒ^�[‘I‘ð)
#--------------------------------------------------------------------------
def update_phase3_actor_select
# ƒRƒ}ƒ“ƒh‘I‘𒆂É�s“®•s”\‚É‚È‚Á‚½�ê�‡
unless @active_actor.inputable?
@active_actor.current_action.clear
command_delete
# ŽŸ‚̃AƒNƒ^�[‚̃Rƒ}ƒ“ƒh“ü—Í‚Ö
phase3_next_actor
return
end
# ƒAƒNƒ^�[ƒAƒ��[‚ð�X�V
@actor_arrow.update
# B ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ�ê�‡
if Input.trigger?(Input::B)
# ƒLƒƒƒ“ƒZƒ‹ SE ‚ð‰‰‘t
$game_system.se_play($data_system.cancel_se)
# ƒAƒNƒ^�[‚Ì‘I‘ð‚ð�I—¹
end_actor_select
return
end
# C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽ�ê�‡
if Input.trigger?(Input::C)
# Œˆ’è SE ‚ð‰‰‘t
$game_system.se_play($data_system.decision_se)
# ƒAƒNƒVƒ‡ƒ“‚ð�Ý’è
@active_actor.current_action.kind = 0
@active_actor.current_action.basic = 0
@active_actor.current_action.target_index = @actor_arrow.index
# ƒAƒNƒ^�[‚Ì‘I‘ð‚ð�I—¹
end_actor_select
# ƒXƒLƒ‹ƒEƒBƒ“ƒhƒE•\Ž¦’†‚Ì�ê�‡
if @skill_window != nil
# ƒAƒNƒVƒ‡ƒ“‚ð�Ä�Ý’è
@active_actor.current_action.kind = 1
# ƒXƒLƒ‹‚Ì‘I‘ð‚ð�I—¹
end_skill_select
end
# ƒAƒCƒeƒ€ƒEƒBƒ“ƒhƒE•\Ž¦’†‚Ì�ê�‡
if @item_window != nil
# ƒAƒNƒVƒ‡ƒ“‚ð�Ä�Ý’è
@active_actor.current_action.kind = 2
# ƒAƒCƒeƒ€‚Ì‘I‘ð‚ð�I—¹
end_item_select
end
# ŽŸ‚̃AƒNƒ^�[‚̃Rƒ}ƒ“ƒh“ü—Í‚Ö
phase3_next_actor
end
end
#--------------------------------------------------------------------------
# �œ ƒGƒlƒ~�[‘I‘ðŠJŽn
#--------------------------------------------------------------------------
alias :start_enemy_select_rtab :start_enemy_select
def start_enemy_select
@camera = "select"
for enemy in $game_troop.enemies
if enemy.exist?
zoom = 1 / enemy.zoom
@spriteset.screen_target(enemy.attack_x(zoom) * 0.75,
enemy.attack_y(zoom) * 0.75, zoom)
break
end
end
# ƒIƒŠƒWƒiƒ‹‚Ì�ˆ—�
start_enemy_select_rtab
end
#--------------------------------------------------------------------------
# �œ ƒGƒlƒ~�[‘I‘ð�I—¹
#--------------------------------------------------------------------------
alias :end_enemy_select_rtab :end_enemy_select
def end_enemy_select
# ƒIƒŠƒWƒiƒ‹‚Ì�ˆ—�
end_enemy_select_rtab
if (@action == 0 and not @action_battlers.empty?) or
(@camera == "select" and (@active_actor.current_action.kind != 0 or
@active_actor.animation1_id != 0))
@spriteset.screen_target(0, 0, 1)
end
end
#--------------------------------------------------------------------------
# �œ ƒXƒLƒ‹‘I‘ðŠJŽn
#--------------------------------------------------------------------------
def start_skill_select
# ƒXƒLƒ‹ƒEƒBƒ“ƒhƒE‚ð�ì�¬
@skill_window = Window_Skill.new(@active_actor)
# ƒwƒ‹ƒvƒEƒBƒ“ƒhƒE‚ðŠÖ˜A•t‚¯
@skill_window.help_window = @help_window
# ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚𖳌ø‰»
@actor_command_window.active = false
@actor_command_window.visible = false
end

#==============================================================================
# �¡ Scene_Battle (•ªŠ„’è‹` 4)
#------------------------------------------------------------------------------
# �@ƒoƒgƒ‹‰æ–Ê‚Ì�ˆ—�‚ð�s‚¤ƒNƒ‰ƒX‚Å‚·�B
#==============================================================================

#--------------------------------------------------------------------------
# �œ ƒ�ƒCƒ“ƒtƒF�[ƒYŠJŽn
#--------------------------------------------------------------------------
def start_phase4
$game_temp.battle_main_phase = true
end

#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V (ƒ�ƒCƒ“ƒtƒF�[ƒY)
#--------------------------------------------------------------------------
def update_phase4
# ƒAƒNƒVƒ‡ƒ“‚ð‹­�§‚³‚ê‚Ä‚¢‚éƒoƒgƒ‰�[‚ª‘¶�Ý‚·‚é�ê�‡
if $game_temp.forcing_battler != nil
battler = $game_temp.forcing_battler
if battler.current_action.forcing == false
if @action_battlers.include?(battler)
if @action > 0 or @action_battlers[0].phase == 1
@action_battlers.delete(battler)
@action_battlers.push(battler)
end
if battler.phase == 1
battler.current_action.forcing = true
force_action(battler)
end
else
battler.current_action.forcing = true
force_action(battler)
action_start(battler)
@action_battlers.delete(battler)
@action_battlers.push(battler)
end
battler.at = @max
battler.atp = 100 * battler.at / @max
end
end
# action ‚ª1ˆÈ�ã‚Ì�ê�‡�Aˆê�Ä‚É�s“®‚ð‹N‚±‚·
for battler in @action_battlers.reverse
# ƒEƒFƒCƒg’†‚Ì�ê�‡
if battler.wait > 0
# ƒEƒFƒCƒgƒJƒEƒ“ƒg‚ðŒ¸‚ç‚·
battler.wait -= 1
break if @action == 0
next
end
unless fin? and battler.phase < 3 and
not $game_system.battle_interpreter.running?
action_phase(battler)
end
break if @action == 0
end
# ƒAƒNƒVƒ‡ƒ“‚ð‹­�§‚³‚ê‚Ä‚¢‚éƒoƒgƒ‰�[‚ª‘¶�Ý‚µ‚È‚¢�ê�‡
if $game_temp.forcing_battler == nil
# ƒoƒgƒ‹ƒCƒxƒ“ƒg‚ðƒZƒbƒgƒAƒbƒv
setup_battle_event
# ƒoƒgƒ‹ƒCƒxƒ“ƒgŽÀ�s’†‚Ì�ê�‡
if $game_system.battle_interpreter.running?
return
end
end
for battler in @action_battlers.reverse
if fin? and battler.phase < 3 and
not $game_system.battle_interpreter.running?
# �퓬‚ª�I—¹‚µ�A‚©‚ƒAƒNƒ^�[‚ª�s“®’¼‘O‚Ì�ê�‡‚̓AƒNƒ^�[‚Ì�s“®‚ð�Á‹Ž
@action_battlers.delete(battler)
end
end
if @action_battlers.empty? and not $game_system.battle_interpreter.running?
# �Ÿ”s”»’è
judge
end
end
#--------------------------------------------------------------------------
# �œ ƒAƒNƒVƒ‡ƒ“�X�V (ƒ�ƒCƒ“ƒtƒF�[ƒY)
#--------------------------------------------------------------------------
def action_phase(battler)
# action ‚ª 1 ‚Ì�ê�‡�Aƒoƒgƒ‰�[‚ª�s“®’†‚©‚Ç‚¤‚©Šm”F
if @action == 1 and battler.phase < 3
for target in battler.target
speller = synthe?(target)
if speller == nil
# ƒ^�[ƒQƒbƒg‚ª’Ê�í�s“®’†‚Ì�ê�‡
if @action_battlers.include?(target)
if target.phase > 2
return
end
end
else
# ƒ^�[ƒQƒbƒg‚ª˜AŒgƒXƒLƒ‹”­“®’†‚Ì�ê�‡
for spell in speller
if @action_battlers.include?(spell)
if spell.phase > 2
return
end
end
end
end
end
end
case battler.phase
when 1
update_phase4_step1(battler)
when 2
update_phase4_step2(battler)
when 3
update_phase4_step3(battler)
when 4
update_phase4_step4(battler)
when 5
update_phase4_step5(battler)
when 6
update_phase4_step6(battler)
end
end
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V (ƒ�ƒCƒ“ƒtƒF�[ƒY ƒXƒeƒbƒv 1 : ƒAƒNƒVƒ‡ƒ“�€”õ)
#--------------------------------------------------------------------------
def update_phase4_step1(battler)
# ‚·‚Å‚É�퓬‚©‚çŠO‚³‚ê‚Ä‚¢‚é�ê�‡
if battler.index == nil
@action_battlers.delete(battler)
anime_wait_return
return
end
speller = synthe?(battler)
if speller == nil
# ƒ_ƒ��[ƒW�H‚ç‚¢’†‚Ì�ê�‡
unless battler.damage.empty? or @action > 2
return
end
# �s“®‰Â”\‚©‚Ç‚¤‚©”»’è
unless battler.movable?
battler.phase = 6
return
end
else
# ƒ_ƒ��[ƒW�H‚ç‚¢’†‚Ì�ê�‡
for spell in speller
unless spell.damage.empty? or @action > 2
return
end
# �s“®‰Â”\‚©‚Ç‚¤‚©”»’è
unless spell.movable?
battler.phase = 6
return
end
end
end
# ƒXƒLƒ‹Žg—pŽž�A‰r�¥ŽžŠÔ�Ý’è
# ‹­�§ƒAƒNƒVƒ‡ƒ“‚©‚ @force ‚ª 2 ‚ÌŽž‚̓XƒLƒ‹‚𑦎ž”­“®
if battler.current_action.kind == 1 and
(not battler.current_action.forcing or @force != 2)
if battler.rtp == 0
# ƒXƒLƒ‹‰r�¥’†‚È‚ç‚Î�A‰ð�œ
skill_reset(battler)
# ƒXƒLƒ‹‰r�¥ŽžŠÔ�Ý’è
recite_time(battler)
# ˜AŒg‹Z�Ý’è
synthe_spell(battler)
# ƒXƒLƒ‹‚ð‰r�¥‚·‚é�ê�‡
if battler.rtp > 0
# ‹­�§ƒAƒNƒVƒ‡ƒ“‚©‚ @force ‚ª 1 ‚ÌŽž‚͘AŒgƒXƒLƒ‹‚Ì‚Ý‘¦Žž”­“®
speller = synthe?(battler)
if battler.current_action.forcing and @force > 0 and speller != nil
for spell in speller
spell.rt = spell.rtp
end
else
battler.blink = true
if battler.current_action.forcing
$game_temp.forcing_battler = nil
battler.current_action.forcing = false
end
@action_battlers.delete(battler)
return
end
end
end
end
# ƒAƒNƒ^�[‚Ì–¾–ŃGƒtƒFƒNƒg OFF
if battler != nil
battler.blink = false
end
speller = synthe?(battler)
if speller == nil
@spell_p.delete(battler)
@spell_e.delete(battler)
else
for spell in speller
spell.blink = false
@spell_p.delete(spell)
@spell_e.delete(spell)
end
end
# ƒXƒeƒbƒv 2 ‚ɈÚ�s
battler.phase = 2
end
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V (ƒ�ƒCƒ“ƒtƒF�[ƒY ƒXƒeƒbƒv 2 : ƒAƒNƒVƒ‡ƒ“ŠJŽn)
#--------------------------------------------------------------------------
def update_phase4_step2(battler)
# ‹­�§ƒAƒNƒVƒ‡ƒ“‚Å‚È‚¯‚ê‚Î
unless battler.current_action.forcing
# �§–ñ‚ª [“G‚ð’Ê�í�UŒ‚‚·‚é] ‚© [–¡•û‚ð’Ê�í�UŒ‚‚·‚é] ‚Ì�ê�‡
if battler.restriction == 2 or battler.restriction == 3
# ƒAƒNƒVƒ‡ƒ“‚É�UŒ‚‚ð�Ý’è
battler.current_action.kind = 0
battler.current_action.basic = 0
end
end
# ƒAƒNƒVƒ‡ƒ“‚ÌŽí•Ê‚Å•ªŠò
case battler.current_action.kind
when 0 # Šî–{
if fin?
battler.phase = 6
return
end
make_basic_action_result(battler)
when 1 # ƒXƒLƒ‹
if fin? and $data_skills[battler.current_action.skill_id].scope == 1..2
battler.phase = 6
return
end
make_skill_action_result(battler)
when 2 # ƒAƒCƒeƒ€
if fin? and $data_items[battler.current_action.item_id].scope == 1..2
battler.phase = 6
return
end
make_item_action_result(battler)
end
if battler.phase == 2
# ƒXƒeƒbƒv 3 ‚ɈÚ�s
battler.phase = 3
end
end
#--------------------------------------------------------------------------
# �œ Šî–{ƒAƒNƒVƒ‡ƒ“ Œ‹‰Ê�ì�¬
#--------------------------------------------------------------------------
def make_basic_action_result(battler)
# �UŒ‚‚Ì�ê�‡
if battler.current_action.basic == 0
# ƒAƒjƒ��[ƒVƒ‡ƒ“ ID ‚ð�Ý’è
battler.anime1 = battler.animation1_id
battler.anime2 = battler.animation2_id
# �s“®‘¤ƒoƒgƒ‰�[‚ªƒGƒlƒ~�[‚Ì�ê�‡
if battler.is_a?(Game_Enemy)
if battler.restriction == 3
target = $game_troop.random_target_enemy
elsif battler.restriction == 2
target = $game_party.random_target_actor
else
index = battler.current_action.target_index
target = $game_party.smooth_target_actor(index)
end
end
# �s“®‘¤ƒoƒgƒ‰�[‚ªƒAƒNƒ^�[‚Ì�ê�‡
if battler.is_a?(Game_Actor)
if battler.restriction == 3
target = $game_party.random_target_actor
elsif battler.restriction == 2
target = $game_troop.random_target_enemy
else
index = battler.current_action.target_index
target = $game_troop.smooth_target_enemy(index)
end
end
# ‘Î�Û‘¤ƒoƒgƒ‰�[‚Ì”z—ñ‚ð�Ý’è
battler.target = [target]
# ’Ê�í�UŒ‚‚ÌŒø‰Ê‚ð“K—p
for target in battler.target
target.attack_effect(battler)
end
return
end
# –hŒä‚Ì�ê�‡
if battler.current_action.basic == 1
return
end
# “¦‚°‚é‚Ì�ê�‡
if battler.is_a?(Game_Enemy) and battler.current_action.basic == 2
# “¦‚°‚é
battler.escape
return
end
# ‰½‚à‚µ‚È‚¢‚Ì�ê�‡
if battler.current_action.basic == 3
# ƒXƒeƒbƒv 6 ‚ɈÚ�s
battler.phase = 6
return
end
end
#--------------------------------------------------------------------------
# �œ ƒXƒLƒ‹‚Ü‚½‚̓AƒCƒeƒ€‚Ì‘Î�Û‘¤ƒoƒgƒ‰�[�Ý’è
# scope : ƒXƒLƒ‹‚Ü‚½‚̓AƒCƒeƒ€‚ÌŒø‰Ê”͈Í
#--------------------------------------------------------------------------
def set_target_battlers(scope, battler)
# �s“®‘¤ƒoƒgƒ‰�[‚ªƒGƒlƒ~�[‚Ì�ê�‡
if battler.is_a?(Game_Enemy)
# Œø‰Ê”͈͂ŕªŠò
case scope
when 1 # “G’P‘Ì
index =battler.current_action.target_index
battler.target.push($game_party.smooth_target_actor(index))
when 2 # “G‘S‘Ì
for actor in $game_party.actors
if actor.exist?
battler.target.push(actor)
end
end
when 3 # –¡•û’P‘Ì
index = battler.current_action.target_index
battler.target.push($game_troop.smooth_target_enemy(index))
when 4 # –¡•û‘S‘Ì
for enemy in $game_troop.enemies
if enemy.exist?
battler.target.push(enemy)
end
end
when 5 # –¡•û’P‘Ì (HP 0)
index = battler.current_action.target_index
enemy = $game_troop.enemies[index]
if enemy != nil and enemy.hp0?
battler.target.push(enemy)
end
when 6 # –¡•û‘S‘Ì (HP 0)
for enemy in $game_troop.enemies
if enemy != nil and enemy.hp0?
battler.target.push(enemy)
end
end
when 7 # Žg—pŽÒ
battler.target.push(battler)
end
end
# �s“®‘¤ƒoƒgƒ‰�[‚ªƒAƒNƒ^�[‚Ì�ê�‡
if battler.is_a?(Game_Actor)
# Œø‰Ê”͈͂ŕªŠò
case scope
when 1 # “G’P‘Ì
index = battler.current_action.target_index
battler.target.push($game_troop.smooth_target_enemy(index))
when 2 # “G‘S‘Ì
for enemy in $game_troop.enemies
if enemy.exist?
battler.target.push(enemy)
end
end
when 3 # –¡•û’P‘Ì
index = battler.current_action.target_index
battler.target.push($game_party.smooth_target_actor(index))
when 4 # –¡•û‘S‘Ì
for actor in $game_party.actors
if actor.exist?
battler.target.push(actor)
end
end
when 5 # –¡•û’P‘Ì (HP 0)
index = battler.current_action.target_index
actor = $game_party.actors[index]
if actor != nil and actor.hp0?
battler.target.push(actor)
end
when 6 # –¡•û‘S‘Ì (HP 0)
for actor in $game_party.actors
if actor != nil and actor.hp0?
battler.target.push(actor)
end
end
when 7 # Žg—pŽÒ
battler.target.push(battler)
end
end
end

 #--------------------------------------------------------------------------
# �œ ƒXƒLƒ‹ƒAƒNƒVƒ‡ƒ“ Œ‹‰Ê�ì�¬
#--------------------------------------------------------------------------
def make_skill_action_result(battler)
# ƒXƒLƒ‹‚ðŽæ“¾
@skill = $data_skills[battler.current_action.skill_id]
# ˜AŒgƒXƒLƒ‹‚Å‚ ‚é‚©‚Ç‚¤‚©Šm”F
speller = synthe?(battler)
# ‹­�§ƒAƒNƒVƒ‡ƒ“‚Å‚È‚¯‚ê‚Î
unless battler.current_action.forcing
# SP �Ø‚ê‚È‚Ç‚ÅŽg—p‚Å‚«‚È‚­‚È‚Á‚½�ê�‡
if speller == nil
unless battler.skill_can_use?(@skill.id)
# ƒXƒeƒbƒv 6 ‚ɈÚ�s
battler.phase = 6
return
end
end
end
# SP �Á”ï
temp = false
if speller != nil
for spell in speller
if spell.current_action.spell_id == 0
spell.sp -= @skill.sp_cost
else
spell.sp -= $data_skills[spell.current_action.spell_id].sp_cost
end
# ƒXƒe�[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðƒŠƒtƒŒƒbƒVƒ…
status_refresh(spell)
end
else
battler.sp -= @skill.sp_cost
# ƒXƒe�[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðƒŠƒtƒŒƒbƒVƒ…
status_refresh(battler)
end
# ƒAƒjƒ��[ƒVƒ‡ƒ“ ID ‚ð�Ý’è
battler.anime1 = @skill.animation1_id
battler.anime2 = @skill.animation2_id
# ƒRƒ‚ƒ“ƒCƒxƒ“ƒg ID ‚ð�Ý’è
battler.event = @skill.common_event_id
# ‘Î�Û‘¤ƒoƒgƒ‰�[‚ð�Ý’è
set_target_battlers(@skill.scope, battler)
# ƒXƒLƒ‹‚ÌŒø‰Ê‚ð“K—p
for target in battler.target
if speller != nil
damage = 0
effective = false
state_p = []
state_m = []
for spell in speller
if spell.current_action.spell_id != 0
@skill = $data_skills[spell.current_action.spell_id]
end
effective |= target.skill_effect(spell, @skill)
if target.damage[spell].class != String
damage += target.damage[spell]
elsif effective == true
effect = target.damage[spell]
end
state_p += target.state_p[spell]
state_m += target.state_m[spell]
target.damage.delete(spell)
target.state_p.delete(spell)
target.state_m.delete(spell)
end
if damage != 0
target.damage[battler] = damage
elsif effective = true
target.damage[battler] = effect
end
target.state_p[battler] = state_p
target.state_m[battler] = state_m
else
target.skill_effect(battler, @skill)
end
end
end
#--------------------------------------------------------------------------
# �œ ƒAƒCƒeƒ€ƒAƒNƒVƒ‡ƒ“ Œ‹‰Ê�ì�¬
#--------------------------------------------------------------------------
def make_item_action_result(battler)
# ƒAƒCƒeƒ€‚ðŽæ“¾
@item = $data_items[battler.current_action.item_id]
# ƒAƒCƒeƒ€�Ø‚ê‚È‚Ç‚ÅŽg—p‚Å‚«‚È‚­‚È‚Á‚½�ê�‡
unless $game_party.item_can_use?(@item.id)
# ƒXƒeƒbƒv 6 ‚ɈÚ�s
battler.phase = 6
return
end
# �Á–Õ•i‚Ì�ê�‡
if @item.consumable
# Žg—p‚µ‚½ƒAƒCƒeƒ€‚ð 1 Œ¸‚ç‚·
$game_party.lose_item(@item.id, 1)
end
# ƒAƒjƒ��[ƒVƒ‡ƒ“ ID ‚ð�Ý’è
battler.anime1 = @item.animation1_id
battler.anime2 = @item.animation2_id
# ƒRƒ‚ƒ“ƒCƒxƒ“ƒg ID ‚ð�Ý’è
battler.event = @item.common_event_id
# ‘Î�Û‚ðŒˆ’è
index = battler.current_action.target_index
target = $game_party.smooth_target_actor(index)
# ‘Î�Û‘¤ƒoƒgƒ‰�[‚ð�Ý’è
set_target_battlers(@item.scope, battler)
# ƒAƒCƒeƒ€‚ÌŒø‰Ê‚ð“K—p
for target in battler.target
target.item_effect(@item, battler)
end
end
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V (ƒ�ƒCƒ“ƒtƒF�[ƒY ƒXƒeƒbƒv 3 : �s“®‘¤ƒAƒjƒ��[ƒVƒ‡ƒ“)
#--------------------------------------------------------------------------
def update_phase4_step3(battler)
# ƒwƒ‹ƒvƒEƒBƒ“ƒhƒE‚Ì�X�V�BƒAƒNƒVƒ‡ƒ“‚ÌŽí•Ê‚Å•ªŠò
case battler.current_action.kind
when 0 # Šî–{
if battler.current_action.basic == 1
@help_window.set_text($data_system.words.guard, 1)
@help_wait = @help_time
end
if battler.is_a?(Game_Enemy) and battler.current_action.basic == 2
@help_window.set_text("“¦‚°‚é", 1)
@help_wait = @help_time
end
when 1 # ƒXƒLƒ‹
skill = $data_skills[battler.current_action.skill_id]
@help_window.set_text(skill.name, 1)
@help_wait = @help_time
when 2 # ƒAƒCƒeƒ€
item = $data_items[battler.current_action.item_id]
@help_window.set_text(item.name, 1)
@help_wait = @help_time
end
# �s“®‘¤ƒAƒjƒ��[ƒVƒ‡ƒ“ (ID ‚ª 0 ‚Ì�ê�‡‚Í”’ƒtƒ‰ƒbƒVƒ…)
if battler.anime1 == 0
battler.white_flash = true
battler.wait = 5
# ƒJƒ�ƒ‰�Ý’è
if battler.target[0].is_a?(Game_Enemy)
camera_set(battler)
end
else
battler.animation.push([battler.anime1, true])
speller = synthe?(battler)
if speller != nil
for spell in speller
if spell != battler
if spell.current_action.spell_id == 0
spell.animation.push([battler.anime1, true])
else
skill = spell.current_action.spell_id
spell.animation.push([$data_skills[skill].animation1_id, true])
spell.current_action.spell_id = 0
end
end
end
end
battler.wait = 2 * $data_animations[battler.anime1].frame_max - 10
end
# ƒXƒeƒbƒv 4 ‚ɈÚ�s
battler.phase = 4
end
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V (ƒ�ƒCƒ“ƒtƒF�[ƒY ƒXƒeƒbƒv 4 : ‘Î�Û‘¤ƒAƒjƒ��[ƒVƒ‡ƒ“)
#--------------------------------------------------------------------------
def update_phase4_step4(battler)
# ƒJƒ�ƒ‰�Ý’è
if battler.target[0].is_a?(Game_Enemy) and battler.anime1 != 0
camera_set(battler)
end
# ‘Î�Û‘¤ƒAƒjƒ��[ƒVƒ‡ƒ“
for target in battler.target
target.animation.push([battler.anime2,
(target.damage[battler] != "Miss")])
unless battler.anime2 == 0
battler.wait = 2 * $data_animations[battler.anime2].frame_max - 10
end
end
# ƒXƒeƒbƒv 5 ‚ɈÚ�s
battler.phase = 5
end
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V (ƒ�ƒCƒ“ƒtƒF�[ƒY ƒXƒeƒbƒv 5 : ƒ_ƒ��[ƒW•\Ž¦)
#--------------------------------------------------------------------------
def update_phase4_step5(battler)
# ƒ_ƒ��[ƒW•\Ž¦
for target in battler.target
if target.damage[battler] != nil
target.damage_pop[battler] = true
target.damage_effect(battler, battler.current_action.kind)
battler.wait = @damage_wait
# ƒXƒe�[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðƒŠƒtƒŒƒbƒVƒ…
status_refresh(target)
end
end
# ƒXƒeƒbƒv 6 ‚ɈÚ�s
battler.phase = 6
end
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V (ƒ�ƒCƒ“ƒtƒF�[ƒY ƒXƒeƒbƒv 6 : ƒŠƒtƒŒƒbƒVƒ…)
#--------------------------------------------------------------------------
def update_phase4_step6(battler)
# ƒJƒ�ƒ‰‚ð–ß‚·
if battler.target[0].is_a?(Game_Enemy) and @camera == battler
@spriteset.screen_target(0, 0, 1)
end
# ƒXƒLƒ‹ƒ‰�[ƒjƒ“ƒO
if battler.target[0].is_a?(Game_Actor) and battler.current_action.kind == 1
for target in battler.target
skill_learning(target, target.class_id,
battler.current_action.skill_id)
end
end
# ƒAƒNƒVƒ‡ƒ“‹­�§‘Î�ۂ̃oƒgƒ‰�[‚ðƒNƒŠƒA
if battler.current_action.forcing == true and
battler.current_action.force_kind == 0 and
battler.current_action.force_basic == 0 and
battler.current_action.force_skill_id == 0
$game_temp.forcing_battler = nil
battler.current_action.forcing = false
end
refresh_phase(battler)
speller = synthe?(battler)
if speller != nil
for spell in speller
if spell != battler
refresh_phase(spell)
end
end
synthe_delete(speller)
end
# ƒRƒ‚ƒ“ƒCƒxƒ“ƒg ID ‚ª—LŒø‚Ì�ê�‡
if battler.event > 0
# ƒCƒxƒ“ƒg‚ðƒZƒbƒgƒAƒbƒv
common_event = $data_common_events[battler.event]
$game_system.battle_interpreter.setup(common_event.list, 0)
end
act = 0
for actor in $game_party.actors + $game_troop.enemies
if actor.movable?
act += 1
end
end
if @turn_cnt >= act and act > 0
@turn_cnt %= act
$game_temp.battle_turn += 1
# ƒoƒgƒ‹ƒCƒxƒ“ƒg‚Ì‘Sƒy�[ƒW‚ðŒŸ�õ
for index in 0...$data_troops[@troop_id].pages.size
# ƒCƒxƒ“ƒgƒy�[ƒW‚ðŽæ“¾
page = $data_troops[@troop_id].pages[index]
# ‚±‚̃y�[ƒW‚̃Xƒpƒ“‚ª [ƒ^�[ƒ“] ‚Ì�ê�‡
if page.span == 1
# ŽÀ�s�ς݃tƒ‰ƒO‚ðƒNƒŠƒA
$game_temp.battle_event_flags[index] = false
end
end
end
battler.phase = 1
@action_battlers.delete(battler)
end

 #--------------------------------------------------------------------------
# �œ ƒŠƒtƒŒƒbƒVƒ…
#--------------------------------------------------------------------------
def refresh_phase(battler)
battler.at %= @max
if battler.movable?
battler.atp = 100 * battler.at / @max
end
spell_reset(battler)
# ƒXƒŠƒbƒvƒ_ƒ��[ƒW
if battler.hp > 0 and battler.slip_damage?
battler.slip_damage_effect
battler.damage_pop["slip"] = true
end
# ƒXƒe�[ƒgŽ©‘R‰ð�œ
battler.remove_states_auto
# ƒXƒe�[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðƒŠƒtƒŒƒbƒVƒ…
status_refresh(battler, true)
unless battler.movable?
return
end
# ƒ^�[ƒ“�”ƒJƒEƒ“ƒg
@turn_cnt += 1
end
#--------------------------------------------------------------------------
# �œ ƒoƒgƒ‰�[ƒAƒNƒVƒ‡ƒ“ƒXƒ^�[ƒg
#--------------------------------------------------------------------------
def action_start(battler)
battler.phase = 1
battler.anime1 = 0
battler.anime2 = 0
battler.target = []
battler.event = 0
@action_battlers.unshift(battler)
end
#--------------------------------------------------------------------------
# �œ ƒXƒe�[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðƒŠƒtƒŒƒbƒVƒ…
#--------------------------------------------------------------------------
def status_refresh(battler, at = false)
if battler.is_a?(Game_Actor)
for i in 0...$game_party.actors.size
if battler == $game_party.actors[i]
number = i + 1
end
end
@status_window.refresh(number)
if at == true
@status_window.at_refresh(number)
end
end
end
#--------------------------------------------------------------------------
# �œ ƒAƒjƒ�ƒEƒFƒCƒg”»’f�ˆ—�
#--------------------------------------------------------------------------
def anime_wait_return
if (@action_battlers.empty? or @anime_wait == false) and
not $game_system.battle_interpreter.running? and not fin?
# ƒGƒlƒ~�[ƒAƒ��[‚ª—LŒø‚Ì�ê�‡
if @enemy_arrow != nil
return [@active - 2, 0].min == 0
# ƒAƒNƒ^�[ƒAƒ��[‚ª—LŒø‚Ì�ê�‡
elsif @actor_arrow != nil
return [@active - 2, 0].min == 0
# ƒXƒLƒ‹ƒEƒBƒ“ƒhƒE‚ª—LŒø‚Ì�ê�‡
elsif @skill_window != nil
return [@active - 3, 0].min == 0
# ƒAƒCƒeƒ€ƒEƒBƒ“ƒhƒE‚ª—LŒø‚Ì�ê�‡
elsif @item_window != nil
return [@active - 3, 0].min == 0
# ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚ª—LŒø‚Ì�ê�‡
elsif @actor_command_window.active
return [@active - 1, 0].min == 0
else
return true
end
else
return false
end
end
#--------------------------------------------------------------------------
# �œ ƒAƒNƒ^�[ƒRƒ}ƒ“ƒh�Á‹Ž”»’f
#--------------------------------------------------------------------------
def command_delete
# ƒGƒlƒ~�[ƒAƒ��[‚ª—LŒø‚Ì�ê�‡
if @enemy_arrow != nil
end_enemy_select
# ƒAƒNƒ^�[ƒAƒ��[‚ª—LŒø‚Ì�ê�‡
elsif @actor_arrow != nil
end_actor_select
end
# ƒXƒLƒ‹ƒEƒBƒ“ƒhƒE‚ª—LŒø‚Ì�ê�‡
if @skill_window != nil
end_skill_select
# ƒAƒCƒeƒ€ƒEƒBƒ“ƒhƒE‚ª—LŒø‚Ì�ê�‡
elsif @item_window != nil
end_item_select
end
# ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚ª—LŒø‚Ì�ê�‡
if @actor_command_window.active
@command.shift
@command_a = false
# ƒ�ƒCƒ“ƒtƒF�[ƒYƒtƒ‰ƒO‚ðƒZƒbƒg
$game_temp.battle_main_phase = true
# ƒAƒNƒ^�[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚𖳌ø‰»
@actor_command_window.active = false
@actor_command_window.visible = false
# ƒAƒNƒ^�[‚Ì–¾–ŃGƒtƒFƒNƒg OFF
if @active_actor != nil
@active_actor.blink = false
end
end
end
#--------------------------------------------------------------------------
# �œ ‹­�§ƒAƒNƒVƒ‡ƒ“�Ý’è
#--------------------------------------------------------------------------
def force_action(battler)
battler.current_action.kind = battler.current_action.force_kind
battler.current_action.basic = battler.current_action.force_basic
battler.current_action.skill_id = battler.current_action.force_skill_id
battler.current_action.force_kind = 0
battler.current_action.force_basic = 0
battler.current_action.force_skill_id = 0
end
#--------------------------------------------------------------------------
# �œ ƒJƒ�ƒ‰ƒZƒbƒg
#--------------------------------------------------------------------------
def camera_set(battler)
@camera = battler
if battler.target.size == 1
if battler.current_action.kind == 0
zoom = 1.2 / battler.target[0].zoom
elsif synthe?(battler) == nil
zoom = 1.5 / battler.target[0].zoom
else
zoom = 2.0 / battler.target[0].zoom
end
@spriteset.screen_target(battler.target[0].attack_x(zoom),
battler.target[0].attack_y(zoom), zoom)
else
@spriteset.screen_target(0, 0, 0.75)
end
end
#--------------------------------------------------------------------------
# �œ ƒXƒLƒ‹‰r�¥ƒ^ƒCƒ€�ì�¬
#--------------------------------------------------------------------------
def recite_time(battler)
end
#--------------------------------------------------------------------------
# �œ ˜AŒgƒXƒLƒ‹”»•Ê
#--------------------------------------------------------------------------
def synthe_spell(battler)
end
#--------------------------------------------------------------------------
# �œ ƒXƒLƒ‹ƒ‰�[ƒjƒ“ƒOƒVƒXƒeƒ€
#--------------------------------------------------------------------------
def skill_learning(actor, class_id, skill_id)
end
#--------------------------------------------------------------------------
# �œ �s“®‰Â”\”»’è
#--------------------------------------------------------------------------
def active?(battler)
speller = synthe?(battler)
if speller != nil
if synthe_delete?(speller)
return false
end
else
unless battler.inputable?
spell_reset(battler)
unless battler.movable?
battler.atp = 0
return false
end
end
if battler.current_action.forcing
spell_reset(battler)
end
end
return true
end
#--------------------------------------------------------------------------
# �œ �‡�¬ƒXƒLƒ‹‰r�¥’†‚©�H
#--------------------------------------------------------------------------
def synthe?(battler)
for speller in @synthe
if speller.include?(battler)
return speller
end
end
return nil
end
#--------------------------------------------------------------------------
# �œ �‡�¬ƒXƒLƒ‹�Á‹Ž”»’f
#--------------------------------------------------------------------------
def synthe_delete?(speller)
for battler in speller
if not battler.inputable? and dead_ok?(battler)
synthe_delete(speller)
return true
end
end
return false
end
#--------------------------------------------------------------------------
# �œ �‡�¬ƒXƒLƒ‹�Á‹Ž
#--------------------------------------------------------------------------
def synthe_delete(speller)
for battler in speller
spell_reset(battler)
if dead_ok?(battler)
@action_battlers.delete(battler)
end
end
@synthe.delete(speller)
end
#--------------------------------------------------------------------------
# �œ ˜AŒgŠÜ‚ÞƒXƒLƒ‹‰r�¥‰ð�œ
#--------------------------------------------------------------------------
def skill_reset(battler)
speller = synthe?(battler)
if speller != nil
synthe_delete(speller)
else
spell_reset(battler)
end
end
#--------------------------------------------------------------------------
# �œ ƒXƒLƒ‹‰r�¥‰ð�œ
#--------------------------------------------------------------------------
def spell_reset(battler)
battler.rt = 0
battler.rtp = 0
battler.blink = false
battler.spell = false
battler.current_action.spell_id = 0
@spell_p.delete(battler)
@spell_e.delete(battler)
end
#--------------------------------------------------------------------------
# �œ �퓬�I—¹”»’è
#--------------------------------------------------------------------------
def fin?
return (victory? or $game_party.all_dead? or $game_party.actors.size == 0)
end
#--------------------------------------------------------------------------
# �œ “G‘S–Å”»’è
#--------------------------------------------------------------------------
def victory?
for battler in $game_troop.enemies
if battler.exist?
return false
end
end
return true
end
#--------------------------------------------------------------------------
# �œ Ž€–S‹–‰Â”»’è
#--------------------------------------------------------------------------
def dead_ok?(battler)
speller = synthe?(battler)
if speller == nil
if @action_battlers.include?(battler)
if battler.phase > 2
return false
end
end
else
for battler in speller
if @action_battlers.include?(battler)
if battler.phase > 2
return false
end
end
end
end
return true
end
end

#==============================================================================
# �¡ Game_Actor
#------------------------------------------------------------------------------
# �@ƒAƒNƒ^�[‚ðˆµ‚¤ƒNƒ‰ƒX‚Å‚·�B‚±‚̃Nƒ‰ƒX‚Í Game_Actors ƒNƒ‰ƒX ($game_actors)
# ‚Ì“à•”‚ÅŽg—p‚³‚ê�AGame_Party ƒNƒ‰ƒX ($game_party) ‚©‚ç‚àŽQ�Æ‚³‚ê‚Ü‚·�B
#==============================================================================

class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# �œ ƒoƒgƒ‹‰æ–Ê X �À•W‚̎擾
#--------------------------------------------------------------------------
def screen_x
# ƒp�[ƒeƒB“à‚Ì•À‚Ñ�‡‚©‚ç X �À•W‚ðŒvŽZ‚µ‚Ä•Ô‚·
if self.index != nil
return self.index * 160 + (4 - $game_party.actors.size) * 80 + 80
else
return 0
end
end
end

#==============================================================================
# �¡ Spriteset_Battle
#------------------------------------------------------------------------------
# �@ƒoƒgƒ‹‰æ–ʂ̃Xƒvƒ‰ƒCƒg‚ð‚Ü‚Æ‚ß‚½ƒNƒ‰ƒX‚Å‚·�B‚±‚̃Nƒ‰ƒX‚Í Scene_Battle ƒNƒ‰
# ƒX‚Ì“à•”‚ÅŽg—p‚³‚ê‚Ü‚·�B
#==============================================================================

class Spriteset_Battle
#--------------------------------------------------------------------------
# �œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï�”
#--------------------------------------------------------------------------
attr_reader :real_x # x�À•W•â�³�iŒ»�Ý’l�j
attr_reader :real_y # y�À•W•â�³�iŒ»�Ý’l�j
attr_reader :real_zoom # Šg‘å—¦�iŒ»�Ý’l�j
#--------------------------------------------------------------------------
# �œ ƒIƒuƒWƒFƒNƒg�‰Šú‰»
#--------------------------------------------------------------------------
def initialize
# ƒrƒ…�[ƒ|�[ƒg‚ð�ì�¬
@viewport1 = Viewport.new(0, 0, 640, 480)
@viewport2 = Viewport.new(0, 0, 640, 480)
@viewport3 = Viewport.new(0, 0, 640, 480)
@viewport4 = Viewport.new(0, 0, 640, 480)
@viewport2.z = 101
@viewport3.z = 200
@viewport4.z = 5000
@wait = 0
@real_x = 0
@real_y = 0
@real_zoom = 1.0
@target_x = 0
@target_y = 0
@target_zoom = 1.0
@gap_x = 0
@gap_y = 0
@gap_zoom = 0.0
# ƒoƒgƒ‹ƒoƒbƒNƒXƒvƒ‰ƒCƒg‚ð�ì�¬
@battleback_sprite = Sprite.new(@viewport1)
# ƒGƒlƒ~�[ƒXƒvƒ‰ƒCƒg‚ð�ì�¬
@enemy_sprites = []
for enemy in $game_troop.enemies.reverse
@enemy_sprites.push(Sprite_Battler.new(@viewport1, enemy))
end
# ƒAƒNƒ^�[ƒXƒvƒ‰ƒCƒg‚ð�ì�¬
@actor_sprites = []
@actor_sprites.push(Sprite_Battler.new(@viewport2))
@actor_sprites.push(Sprite_Battler.new(@viewport2))
@actor_sprites.push(Sprite_Battler.new(@viewport2))
@actor_sprites.push(Sprite_Battler.new(@viewport2))
# “VŒó‚ð�ì�¬
@weather = RPG::Weather.new(@viewport1)
# ƒsƒNƒ`ƒƒƒXƒvƒ‰ƒCƒg‚ð�ì�¬
@picture_sprites = []
for i in 51..100
@picture_sprites.push(Sprite_Picture.new(@viewport3,
$game_screen.pictures[i]))
end
# ƒ^ƒCƒ}�[ƒXƒvƒ‰ƒCƒg‚ð�ì�¬
@timer_sprite = Sprite_Timer.new
# ƒtƒŒ�[ƒ€�X�V
update
end
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V
#--------------------------------------------------------------------------
def update
# ƒAƒNƒ^�[ƒXƒvƒ‰ƒCƒg‚Ì“à—e‚ð�X�V (ƒAƒNƒ^�[‚Ì“ü‚ê‘Ö‚¦‚ɑΉž)
@actor_sprites[0].battler = $game_party.actors[0]
@actor_sprites[1].battler = $game_party.actors[1]
@actor_sprites[2].battler = $game_party.actors[2]
@actor_sprites[3].battler = $game_party.actors[3]
# ƒoƒgƒ‹ƒoƒbƒN‚̃tƒ@ƒCƒ‹–¼‚ªŒ»�Ý‚Ì‚à‚̂ƈႤ�ê�‡
if @battleback_name != $game_temp.battleback_name
make_battleback
end
# ‰æ–ʂ̃XƒNƒ��[ƒ‹
screen_scroll
# ƒ‚ƒ“ƒXƒ^�[‚̈ʒu•â�³
for enemy in $game_troop.enemies
enemy.real_x = @real_x
enemy.real_y = @real_y
enemy.real_zoom = @real_zoom
end
# ƒoƒgƒ‰�[ƒXƒvƒ‰ƒCƒg‚ð�X�V
for sprite in @enemy_sprites + @actor_sprites
sprite.update
end
# “VŒóƒOƒ‰ƒtƒBƒbƒN‚ð�X�V
@weather.type = $game_screen.weather_type
@weather.max = $game_screen.weather_max
@weather.update
# ƒsƒNƒ`ƒƒƒXƒvƒ‰ƒCƒg‚ð�X�V
for sprite in @picture_sprites
sprite.update
end
# ƒ^ƒCƒ}�[ƒXƒvƒ‰ƒCƒg‚ð�X�V
@timer_sprite.update
# ‰æ–Ê‚Ì�F’²‚ƃVƒFƒCƒNˆÊ’u‚ð�Ý’è
@viewport1.tone = $game_screen.tone
@viewport1.ox = $game_screen.shake
# ‰æ–ʂ̃tƒ‰ƒbƒVƒ…�F‚ð�Ý’è
@viewport4.color = $game_screen.flash_color
# ƒrƒ…�[ƒ|�[ƒg‚ð�X�V
@viewport1.update
@viewport2.update
@viewport4.update
end
#--------------------------------------------------------------------------
# �œ ƒoƒgƒ‹”wŒi‚Ì�Ý’è
#--------------------------------------------------------------------------
def make_battleback
@battleback_name = $game_temp.battleback_name
if @battleback_sprite.bitmap != nil
@battleback_sprite.bitmap.dispose
end
@battleback_sprite.bitmap = RPG::Cache.battleback(@battleback_name)
if @battleback_sprite.bitmap.width == 640 and
@battleback_sprite.bitmap.height == 320
@battleback_sprite.src_rect.set(0, 0, 1280, 640)
@base_zoom = 2.0
@battleback_sprite.zoom_x = @base_zoom
@battleback_sprite.zoom_y = @base_zoom
@real_y = 4
@battleback_sprite.x = 320
@battleback_sprite.y = @real_y
@battleback_sprite.ox = @battleback_sprite.bitmap.width / 2
@battleback_sprite.oy = @battleback_sprite.bitmap.height / 4
elsif @battleback_sprite.bitmap.width == 640 and
@battleback_sprite.bitmap.height == 480
@battleback_sprite.src_rect.set(0, 0, 960, 720)
@base_zoom = 1.5
@battleback_sprite.zoom_x = @base_zoom
@battleback_sprite.zoom_y = @base_zoom
@battleback_sprite.x = 320
@battleback_sprite.y = 0
@battleback_sprite.ox = @battleback_sprite.bitmap.width / 2
@battleback_sprite.oy = @battleback_sprite.bitmap.height / 4
else
@battleback_sprite.src_rect.set(0, 0, @battleback_sprite.bitmap.width,
@battleback_sprite.bitmap.height)
@base_zoom = 1.0
@battleback_sprite.zoom_x = @base_zoom
@battleback_sprite.zoom_y = @base_zoom
@battleback_sprite.x = 320
@battleback_sprite.y = 0
@battleback_sprite.ox = @battleback_sprite.bitmap.width / 2
@battleback_sprite.oy = @battleback_sprite.bitmap.height / 4
end
end
#--------------------------------------------------------------------------
# �œ ‰æ–ʂ̃XƒNƒ��[ƒ‹–Ú•W‚̈ʒu�EŠg‘å—¦�Ý’è
#--------------------------------------------------------------------------
def screen_target(x, y, zoom)
return unless $scene.drive
@wait = $scene.scroll_time
@target_x = x
@target_y = y
@target_zoom = zoom
screen_over
@gap_x = @target_x - @real_x
@gap_y = @target_y - @real_y
@gap_zoom = @target_zoom - @real_zoom
end
#--------------------------------------------------------------------------
# �œ ‰æ–ʂ̃XƒNƒ��[ƒ‹
#--------------------------------------------------------------------------
def screen_scroll
if @wait > 0
@real_x = @target_x - @gap_x * (@wait ** 2) / ($scene.scroll_time ** 2)
@real_y = @target_y - @gap_y * (@wait ** 2) / ($scene.scroll_time ** 2)
@real_zoom = @target_zoom -
@gap_zoom * (@wait ** 2) / ($scene.scroll_time ** 2)
@battleback_sprite.x = 320 + @real_x
@battleback_sprite.y = @real_y
@battleback_sprite.zoom_x = @base_zoom * @real_zoom
@battleback_sprite.zoom_y = @base_zoom * @real_zoom
@battleback_sprite.ox = @battleback_sprite.bitmap.width / 2
@battleback_sprite.oy = @battleback_sprite.bitmap.height / 4
@wait -= 1
end
end
#--------------------------------------------------------------------------
# �œ ƒXƒNƒŠ�[ƒ“‚ª‰æ–ÊŠO‚É�o‚½Žž‚Ì•â�³�ˆ—�
#--------------------------------------------------------------------------
def screen_over
width = @battleback_sprite.bitmap.width * @base_zoom * @target_zoom / 2
unless 324 + @target_x > width and 324 - @target_x > width
if 324 + @target_x > width
@target_x = width - 324
elsif 324 - @target_x > width
@target_x = 324 - width
end
end
height = @battleback_sprite.bitmap.height * @base_zoom * @target_zoom / 4
unless @target_y > height - 4 and 484 - @target_y > 3 * height
if @target_y > height - 4
@target_y = height - 4
elsif 484 - @target_y > 3 * height
@target_y = 484 - 3 * height
end
end
end
end

#==============================================================================
# �¡ Game_Battler (•ªŠ„’è‹` 1)
#------------------------------------------------------------------------------
# �@ƒoƒgƒ‰�[‚ðˆµ‚¤ƒNƒ‰ƒX‚Å‚·�B‚±‚̃Nƒ‰ƒX‚Í Game_Actor ƒNƒ‰ƒX‚Æ Game_Enemy ƒNƒ‰
# ƒX‚̃X�[ƒp�[ƒNƒ‰ƒX‚Æ‚µ‚ÄŽg—p‚³‚ê‚Ü‚·�B
#==============================================================================

class Game_Battler
#--------------------------------------------------------------------------
# �œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï�”’ljÁ
#--------------------------------------------------------------------------
attr_accessor :up_level # ƒŒƒxƒ‹ƒAƒbƒv�”
attr_accessor :at # AT�iƒ^ƒCƒ€ƒQ�[ƒW�j
attr_accessor :atp # AT�i•\Ž¦—p�j
attr_accessor :rt # RP�i‰r�¥ƒQ�[ƒW�j
attr_accessor :rtp # RP�i‰r�¥•K—v—Ê�j
attr_accessor :spell # �‡�¬ƒXƒLƒ‹”­“®’†
attr_accessor :recover_hp # HP‰ñ•œ—Ê
attr_accessor :recover_sp # SP‰ñ•œ—Ê
attr_accessor :state_p # ƒXƒe�[ƒ^ƒXˆÙ�í”z—ñ
attr_accessor :state_m # ƒXƒe�[ƒ^ƒXˆÙ�í”z—ñ
attr_accessor :damage_sp # SPƒ_ƒ��[ƒW•\Ž¦ƒtƒ‰ƒO
attr_accessor :animation # ƒAƒjƒ��[ƒVƒ‡ƒ“ ID, Hit‚Ì”z—ñ
attr_accessor :phase
attr_accessor :wait
attr_accessor :target
attr_accessor :anime1
attr_accessor :anime2
attr_accessor :event
#--------------------------------------------------------------------------
# �œ ƒIƒuƒWƒFƒNƒg�‰Šú‰»
#--------------------------------------------------------------------------
alias :initialize_rtab :initialize
def initialize
initialize_rtab
@damage_pop = {}
@damage = {}
@damage_sp = {}
@critical = {}
@recover_hp = {}
@recover_sp = {}
@state_p = {}
@state_m = {}
@animation = []
@phase = 1
@wait = 0
@target = []
@anime1 = 0
@anime2 = 0
@event = 0
end
#--------------------------------------------------------------------------
# �œ ‘¶�Ý”»’è
#--------------------------------------------------------------------------
def exist?
return (not @hidden and (@hp > 0 or @immortal or @damage_pop.size > 0))
end
#--------------------------------------------------------------------------
# �œ ƒXƒe�[ƒg‚̉ð�œ
# state_id : ƒXƒe�[ƒg ID
# force : ‹­�§‰ð�œƒtƒ‰ƒO (ƒI�[ƒgƒXƒe�[ƒg‚Ì�ˆ—�‚ÅŽg—p)
#--------------------------------------------------------------------------
def remove_state(state_id, force = false)
# ‚±‚̃Xƒe�[ƒg‚ª•t‰Á‚³‚ê‚Ä‚¢‚é�ê�‡
if state?(state_id)
# ‹­�§•t‰Á‚³‚ꂽƒXƒe�[ƒg‚Å�A‚©‚‰ð�œ‚ª‹­�§‚Å‚Í‚È‚¢�ê�‡
if @states_turn[state_id] == -1 and not force
# ƒ�ƒ\ƒbƒh�I—¹
return
end
# Œ»�Ý‚Ì HP ‚ª 0 ‚©‚ ƒIƒvƒVƒ‡ƒ“ [HP 0 ‚Ì�ó‘Ô‚Æ‚Ý‚È‚·] ‚ª—LŒø‚Ì�ê�‡
if @hp == 0 and $data_states[state_id].zero_hp
# ‚Ù‚©‚É [HP 0 ‚Ì�ó‘Ô‚Æ‚Ý‚È‚·] ƒXƒe�[ƒg‚ª‚ ‚é‚©‚Ç‚¤‚©”»’è
zero_hp = false
for i in @states
if i != state_id and $data_states[i].zero_hp
zero_hp = true
end
end
# �퓬•s”\‚ð‰ð�œ‚µ‚Ă悯‚ê‚Î�AHP ‚ð 1 ‚É•Ï�X
if zero_hp == false
@hp = 1
end
end
unless self.movable?
# ƒXƒe�[ƒg ID ‚ð @states ”z—ñ‚¨‚æ‚Ñ @states_turn ƒnƒbƒVƒ…‚©‚ç�í�œ
@states.delete(state_id)
@states_turn.delete(state_id)
if self.movable?
self.at = 0
end
else
# ƒXƒe�[ƒg ID ‚ð @states ”z—ñ‚¨‚æ‚Ñ @states_turn ƒnƒbƒVƒ…‚©‚ç�í�œ
@states.delete(state_id)
@states_turn.delete(state_id)
end
end
# HP ‚¨‚æ‚Ñ SP ‚Ì�Å‘å’lƒ`ƒFƒbƒN
@hp = [@hp, self.maxhp].min
@sp = [@sp, self.maxsp].min
end
#--------------------------------------------------------------------------
# �œ ’Ê�í�UŒ‚‚ÌŒø‰Ê“K—p
# attacker : �UŒ‚ŽÒ (ƒoƒgƒ‰�[)
#--------------------------------------------------------------------------
def attack_effect(attacker)
# ƒNƒŠƒeƒBƒJƒ‹ƒtƒ‰ƒO‚ðƒNƒŠƒA
self.critical[attacker] = false
state_p[attacker] = []
state_m[attacker] = []
# ‘æˆê–½’†”»’è
hit_result = (rand(100) < attacker.hit)
# –½’†‚Ì�ê�‡
if hit_result == true
# Šî–{ƒ_ƒ��[ƒW‚ðŒvŽZ
atk = [attacker.atk - self.pdef / 2, 0].max
self.damage[attacker] = atk * (20 + attacker.str) / 20
# ‘®�«�C�³
self.damage[attacker] *= elements_correct(attacker.element_set)
self.damage[attacker] /= 100
# ƒ_ƒ��[ƒW‚Ì•„�†‚ª�³‚Ì�ê�‡
if self.damage[attacker] > 0
# ƒNƒŠƒeƒBƒJƒ‹�C�³
if rand(100) < 4 * attacker.dex / self.agi
self.damage[attacker] *= 2
self.critical[attacker] = true
end
# –hŒä�C�³
if self.guarding?
self.damage[attacker] /= 2
end
end
# •ªŽU
if self.damage[attacker].abs > 0
amp = [self.damage[attacker].abs * 15 / 100, 1].max
self.damage[attacker] += rand(amp+1) + rand(amp+1) - amp
end
# ‘æ“ñ–½’†”»’è
eva = 8 * self.agi / attacker.dex + self.eva
hit = self.damage[attacker] < 0 ? 100 : 100 - eva
hit = self.cant_evade? ? 100 : hit
hit_result = (rand(100) < hit)
end
# –½’†‚Ì�ê�‡
if hit_result == true
# ƒXƒe�[ƒg�ÕŒ‚‰ð�œ
remove_states_shock
# HP ‚©‚çƒ_ƒ��[ƒW‚ðŒ¸ŽZ
# ƒXƒe�[ƒg•Ï‰»
@state_changed = false
states_plus(attacker, attacker.plus_state_set)
states_minus(attacker, attacker.minus_state_set)
# ƒ~ƒX‚Ì�ê�‡
else
# ƒ_ƒ��[ƒW‚É "Miss" ‚ð�Ý’è
self.damage[attacker] = "Miss"
# ƒNƒŠƒeƒBƒJƒ‹ƒtƒ‰ƒO‚ðƒNƒŠƒA
self.critical[attacker] = false
end
# ƒ�ƒ\ƒbƒh�I—¹
return true
end

 #--------------------------------------------------------------------------
# �œ ƒXƒLƒ‹‚ÌŒø‰Ê“K—p
# user : ƒXƒLƒ‹‚ÌŽg—pŽÒ (ƒoƒgƒ‰�[)
# skill : ƒXƒLƒ‹
#--------------------------------------------------------------------------
def skill_effect(user, skill)
# ƒNƒŠƒeƒBƒJƒ‹ƒtƒ‰ƒO‚ðƒNƒŠƒA
self.critical[user] = false
state_p[user] = []
state_m[user] = []
# ƒXƒLƒ‹‚ÌŒø‰Ê”͈͂ª HP 1 ˆÈ�ã‚Ì–¡•û‚Å�AŽ©•ª‚Ì HP ‚ª 0�A
# ‚Ü‚½‚̓XƒLƒ‹‚ÌŒø‰Ê”͈͂ª HP 0 ‚Ì–¡•û‚Å�AŽ©•ª‚Ì HP ‚ª 1 ˆÈ�ã‚Ì�ê�‡
if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or
((skill.scope == 5 or skill.scope == 6) and self.hp >= 1)
# ƒ�ƒ\ƒbƒh�I—¹
return false
end
# —LŒøƒtƒ‰ƒO‚ðƒNƒŠƒA
effective = false
# ƒRƒ‚ƒ“ƒCƒxƒ“ƒg ID ‚ª—LŒø‚Ì�ê�‡‚Í—LŒøƒtƒ‰ƒO‚ðƒZƒbƒg
effective |= skill.common_event_id > 0
# ‘æˆê–½’†”»’è
hit = skill.hit
if skill.atk_f > 0
hit *= user.hit / 100
end
hit_result = (rand(100) < hit)
# •sŠmŽÀ‚ȃXƒLƒ‹‚Ì�ê�‡‚Í—LŒøƒtƒ‰ƒO‚ðƒZƒbƒg
effective |= hit < 100
# –½’†‚Ì�ê�‡
if hit_result == true
# ˆÐ—Í‚ðŒvŽZ
power = skill.power + user.atk * skill.atk_f / 100
if power > 0
power -= self.pdef * skill.pdef_f / 200
power -= self.mdef * skill.mdef_f / 200
power = [power, 0].max
end
# ”{—¦‚ðŒvŽZ
rate = 20
rate += (user.str * skill.str_f / 100)
rate += (user.dex * skill.dex_f / 100)
rate += (user.agi * skill.agi_f / 100)
rate += (user.int * skill.int_f / 100)
# Šî–{ƒ_ƒ��[ƒW‚ðŒvŽZ
self.damage[user] = power * rate / 20
# ‘®�«�C�³
self.damage[user] *= elements_correct(skill.element_set)
self.damage[user] /= 100
# ƒ_ƒ��[ƒW‚Ì•„�†‚ª�³‚Ì�ê�‡
if self.damage[user] > 0
# –hŒä�C�³
if self.guarding?
self.damage[user] /= 2
end
end
# •ªŽU
if skill.variance > 0 and self.damage[user].abs > 0
amp = [self.damage[user].abs * skill.variance / 100, 1].max
self.damage[user] += rand(amp+1) + rand(amp+1) - amp
end
# ‘æ“ñ–½’†”»’è
eva = 8 * self.agi / user.dex + self.eva
hit = self.damage[user] < 0 ? 100 : 100 - eva * skill.eva_f / 100
hit = self.cant_evade? ? 100 : hit
hit_result = (rand(100) < hit)
# •sŠmŽÀ‚ȃXƒLƒ‹‚Ì�ê�‡‚Í—LŒøƒtƒ‰ƒO‚ðƒZƒbƒg
effective |= hit < 100
end
# –½’†‚Ì�ê�‡
if hit_result == true
# ˆÐ—Í 0 ˆÈŠO‚Ì•¨—��UŒ‚‚Ì�ê�‡
if skill.power != 0 and skill.atk_f > 0
# ƒXƒe�[ƒg�ÕŒ‚‰ð�œ
remove_states_shock
# —LŒøƒtƒ‰ƒO‚ðƒZƒbƒg
effective = true
end
# HP ‚Ì•Ï“®”»’è
last_hp = [[self.hp - self.damage[user], self.maxhp].min, 0].max
# Œø‰Ê”»’è
effective |= self.hp != last_hp
# ƒXƒe�[ƒg•Ï‰»
@state_changed = false
effective |= states_plus(user, skill.plus_state_set)
effective |= states_minus(user, skill.minus_state_set)
unless $game_temp.in_battle
self.damage_effect(user, 1)
end
# ˆÐ—Í‚ª 0 ‚Ì�ê�‡
if skill.power == 0
# ƒ_ƒ��[ƒW‚ɋ󕶎š—ñ‚ð�Ý’è
self.damage[user] = ""
# ƒXƒe�[ƒg‚ɕω»‚ª‚È‚¢�ê�‡
unless @state_changed
# ƒ_ƒ��[ƒW‚É "Miss" ‚ð�Ý’è
self.damage[user] = "Miss"
end
end
# ƒ~ƒX‚Ì�ê�‡
else
# ƒ_ƒ��[ƒW‚É "Miss" ‚ð�Ý’è
self.damage[user] = "Miss"
end
# �퓬’†‚Å‚È‚¢�ê�‡
unless $game_temp.in_battle
# ƒ_ƒ��[ƒW‚É nil ‚ð�Ý’è
self.damage[user] = nil
end
# ƒ�ƒ\ƒbƒh�I—¹
return effective
end
#--------------------------------------------------------------------------
# �œ ƒAƒCƒeƒ€‚ÌŒø‰Ê“K—p
# item : ƒAƒCƒeƒ€
#--------------------------------------------------------------------------
def item_effect(item, user = $game_party.actors[0])
# ƒNƒŠƒeƒBƒJƒ‹ƒtƒ‰ƒO‚ðƒNƒŠƒA
self.critical[user] = false
state_p[user] = []
state_m[user] = []
# ƒAƒCƒeƒ€‚ÌŒø‰Ê”͈͂ª HP 1 ˆÈ�ã‚Ì–¡•û‚Å�AŽ©•ª‚Ì HP ‚ª 0�A
# ‚Ü‚½‚̓AƒCƒeƒ€‚ÌŒø‰Ê”͈͂ª HP 0 ‚Ì–¡•û‚Å�AŽ©•ª‚Ì HP ‚ª 1 ˆÈ�ã‚Ì�ê�‡
if ((item.scope == 3 or item.scope == 4) and self.hp == 0) or
((item.scope == 5 or item.scope == 6) and self.hp >= 1)
# ƒ�ƒ\ƒbƒh�I—¹
return false
end
# —LŒøƒtƒ‰ƒO‚ðƒNƒŠƒA
effective = false
# ƒRƒ‚ƒ“ƒCƒxƒ“ƒg ID ‚ª—LŒø‚Ì�ê�‡‚Í—LŒøƒtƒ‰ƒO‚ðƒZƒbƒg
effective |= item.common_event_id > 0
# –½’†”»’è
hit_result = (rand(100) < item.hit)
# •sŠmŽÀ‚ȃXƒLƒ‹‚Ì�ê�‡‚Í—LŒøƒtƒ‰ƒO‚ðƒZƒbƒg
effective |= item.hit < 100
# –½’†‚Ì�ê�‡
if hit_result == true
# ‰ñ•œ—Ê‚ðŒvŽZ
self.recover_hp[user] = maxhp * item.recover_hp_rate / 100 +
item.recover_hp
self.recover_sp[user] = maxsp * item.recover_sp_rate / 100 +
item.recover_sp
if self.recover_hp[user] < 0
self.recover_hp[user] += self.pdef * item.pdef_f / 20
self.recover_hp[user] += self.mdef * item.mdef_f / 20
self.recover_hp[user] = [self.recover_hp[user], 0].min
end
# ‘®�«�C�³
self.recover_hp[user] *= elements_correct(item.element_set)
self.recover_hp[user] /= 100
self.recover_sp[user] *= elements_correct(item.element_set)
self.recover_sp[user] /= 100
# •ªŽU
if item.variance > 0 and self.recover_hp[user].abs > 0
amp = [self.recover_hp[user].abs * item.variance / 100, 1].max
self.recover_hp[user] += rand(amp+1) + rand(amp+1) - amp
end
if item.variance > 0 and self.recover_sp[user].abs > 0
amp = [self.recover_sp[user].abs * item.variance / 100, 1].max
self.recover_sp[user] += rand(amp+1) + rand(amp+1) - amp
end
# ‰ñ•œ—Ê‚Ì•„�†‚ª•‰‚Ì�ê�‡
if self.recover_hp[user] < 0
# –hŒä�C�³
if self.guarding?
self.recover_hp[user] /= 2
end
end
# HP ‰ñ•œ—Ê‚Ì•„�†‚𔽓]‚µ�Aƒ_ƒ��[ƒW‚Ì’l‚É�Ý’è
self.damage[user] = -self.recover_hp[user]
# HP ‚¨‚æ‚Ñ SP ‚Ì•Ï“®”»’è
last_hp = [[self.hp + self.recover_hp[user], self.maxhp].min, 0].max
last_sp = [[self.sp + self.recover_sp[user], self.maxsp].min, 0].max
effective |= self.hp != last_hp
effective |= self.sp != last_sp
# ƒXƒe�[ƒg•Ï‰»
@state_changed = false
effective |= states_plus(user, item.plus_state_set)
effective |= states_minus(user, item.minus_state_set)
unless $game_temp.in_battle
self.damage_effect(user, 2)
end
# ƒpƒ‰ƒ��[ƒ^�ã�¸’l‚ª—LŒø‚Ì�ê�‡
if item.parameter_type > 0 and item.parameter_points != 0
# ƒpƒ‰ƒ��[ƒ^‚Å•ªŠò
case item.parameter_type
when 1 # MaxHP
@maxhp_plus += item.parameter_points
when 2 # MaxSP
@maxsp_plus += item.parameter_points
when 3 # ˜r—Í
@str_plus += item.parameter_points
when 4 # Ší—p‚³
@dex_plus += item.parameter_points
when 5 # ‘f‘�‚³
@agi_plus += item.parameter_points
when 6 # –‚—Í
@int_plus += item.parameter_points
end
# —LŒøƒtƒ‰ƒO‚ðƒZƒbƒg
effective = true
end
# HP ‰ñ•œ—¦‚Ɖñ•œ—Ê‚ª 0 ‚Ì�ê�‡
if item.recover_hp_rate == 0 and item.recover_hp == 0
# ƒ_ƒ��[ƒW‚ɋ󕶎š—ñ‚ð�Ý’è
self.damage[user] = ""
# SP ‰ñ•œ—¦‚Ɖñ•œ—Ê‚ª 0�Aƒpƒ‰ƒ��[ƒ^�ã�¸’l‚ª–³Œø‚Ì�ê�‡
if item.recover_sp_rate == 0 and item.recover_sp == 0 and
(item.parameter_type == 0 or item.parameter_points == 0)
# ƒXƒe�[ƒg‚ɕω»‚ª‚È‚¢�ê�‡
unless @state_changed
# ƒ_ƒ��[ƒW‚É "Miss" ‚ð�Ý’è
self.damage[user] = "Miss"
end
end
end
# ƒ~ƒX‚Ì�ê�‡
else
# ƒ_ƒ��[ƒW‚É "Miss" ‚ð�Ý’è
self.damage[user] = "Miss"
end
# �퓬’†‚Å‚È‚¢�ê�‡
unless $game_temp.in_battle
# ƒ_ƒ��[ƒW‚É nil ‚ð�Ý’è
self.damage[user] = nil
end
# ƒ�ƒ\ƒbƒh�I—¹
return effective
end
#--------------------------------------------------------------------------
# �œ ƒXƒe�[ƒg•Ï‰» (+) ‚Ì“K—p
# plus_state_set : ƒXƒe�[ƒg•Ï‰» (+)
#--------------------------------------------------------------------------
def states_plus(battler, plus_state_set)
# —LŒøƒtƒ‰ƒO‚ðƒNƒŠƒA
effective = false
# ƒ‹�[ƒv (•t‰Á‚·‚éƒXƒe�[ƒg)
for i in plus_state_set
# ‚±‚̃Xƒe�[ƒg‚ª–hŒä‚³‚ê‚Ä‚¢‚È‚¢�ê�‡
unless self.state_guard?(i)
# ‚±‚̃Xƒe�[ƒg‚ªƒtƒ‹‚Å‚È‚¯‚ê‚ΗLŒøƒtƒ‰ƒO‚ðƒZƒbƒg
effective |= self.state_full?(i) == false
# ƒXƒe�[ƒg‚ª [’ï�R‚µ‚È‚¢] ‚Ì�ê�‡
if $data_states[i].nonresistance
# ƒXƒe�[ƒg•Ï‰»ƒtƒ‰ƒO‚ðƒZƒbƒg
@state_changed = true
# ƒXƒe�[ƒg‚ð•t‰Á
add_state(i)
# ‚±‚̃Xƒe�[ƒg‚ªƒtƒ‹‚Å‚Í‚È‚¢�ê�‡
elsif self.state_full?(i) == false
# ƒXƒe�[ƒg—LŒø“x‚ðŠm—¦‚É•ÏŠ·‚µ�A—��”‚Æ”äŠr
if rand(100) < [0,100,80,60,40,20,0][self.state_ranks[i]]
# ƒXƒe�[ƒg•Ï‰»ƒtƒ‰ƒO‚ðƒZƒbƒg
@state_changed = true
# ƒXƒe�[ƒg‚ð•t‰Á
self.state_p[battler].push(i)
end
end
end
end
# ƒ�ƒ\ƒbƒh�I—¹
return effective
end

 #--------------------------------------------------------------------------
# �œ ƒXƒe�[ƒg•Ï‰» (-) ‚Ì“K—p
# minus_state_set : ƒXƒe�[ƒg•Ï‰» (-)
#--------------------------------------------------------------------------
def states_minus(battler, minus_state_set)
# —LŒøƒtƒ‰ƒO‚ðƒNƒŠƒA
effective = false
# ƒ‹�[ƒv (‰ð�œ‚·‚éƒXƒe�[ƒg)
for i in minus_state_set
# ‚±‚̃Xƒe�[ƒg‚ª•t‰Á‚³‚ê‚Ä‚¢‚ê‚ΗLŒøƒtƒ‰ƒO‚ðƒZƒbƒg
effective |= self.state?(i)
# ƒXƒe�[ƒg•Ï‰»ƒtƒ‰ƒO‚ðƒZƒbƒg
@state_changed = true
# ƒXƒe�[ƒg‚ð‰ð�œ
self.state_m[battler].push(i)
end
# ƒ�ƒ\ƒbƒh�I—¹
return effective
end
#--------------------------------------------------------------------------
# �œ ƒ_ƒ��[ƒW‰‰ŽZ
#--------------------------------------------------------------------------
def damage_effect(battler, item)
if item == 2
self.hp += self.recover_hp[battler]
self.sp += self.recover_sp[battler]
if self.recover_sp[battler] != 0
self.damage_sp[battler] = -self.recover_sp[battler]
end
else
if self.damage[battler].class != String
self.hp -= self.damage[battler]
end
end
for i in self.state_p[battler]
add_state(i)
end
for i in self.state_m[battler]
remove_state(i)
end
end
#--------------------------------------------------------------------------
# �œ ƒXƒŠƒbƒvƒ_ƒ��[ƒW‚ÌŒø‰Ê“K—p
#--------------------------------------------------------------------------
def slip_damage_effect
# ƒ_ƒ��[ƒW‚ð�Ý’è
self.damage["slip"] = self.maxhp / 10
# •ªŽU
if self.damage["slip"].abs > 0
amp = [self.damage["slip"].abs * 15 / 100, 1].max
self.damage["slip"] += rand(amp+1) + rand(amp+1) - amp
end
# HP ‚©‚çƒ_ƒ��[ƒW‚ðŒ¸ŽZ
self.hp -= self.damage["slip"]
# ƒ�ƒ\ƒbƒh�I—¹
return true
end
end

#==============================================================================
# �¡ Game_BattleAction
#------------------------------------------------------------------------------
# �@ƒAƒNƒVƒ‡ƒ“ (�퓬’†‚Ì�s“®) ‚ðˆµ‚¤ƒNƒ‰ƒX‚Å‚·�B‚±‚̃Nƒ‰ƒX‚Í Game_Battler ƒNƒ‰
# ƒX‚Ì“à•”‚ÅŽg—p‚³‚ê‚Ü‚·�B
#==============================================================================

class Game_BattleAction
#--------------------------------------------------------------------------
# �œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï�”
#--------------------------------------------------------------------------
attr_accessor :spell_id # �‡‘Ì–‚–@—pƒXƒLƒ‹ ID
attr_accessor :force_kind # Ží•Ê (Šî–{ / ƒXƒLƒ‹ / ƒAƒCƒeƒ€)
attr_accessor :force_basic # Šî–{ (�UŒ‚ / –hŒä / “¦‚°‚é)
attr_accessor :force_skill_id # ƒXƒLƒ‹ ID
#--------------------------------------------------------------------------
# �œ —LŒø”»’è
#--------------------------------------------------------------------------
def valid?
return (not (@force_kind == 0 and @force_basic == 3))
end
end

#==============================================================================
# �¡ Game_Actor
#------------------------------------------------------------------------------
# �@ƒAƒNƒ^�[‚ðˆµ‚¤ƒNƒ‰ƒX‚Å‚·�B‚±‚̃Nƒ‰ƒX‚Í Game_Actors ƒNƒ‰ƒX ($game_actors)
# ‚Ì“à•”‚ÅŽg—p‚³‚ê�AGame_Party ƒNƒ‰ƒX ($game_party) ‚©‚ç‚àŽQ�Æ‚³‚ê‚Ü‚·�B
#==============================================================================

class Game_Actor < Game_Battler
def skill_can_use?(skill_id)
return super
end
end

#==============================================================================
# �¡ Game_Enemy
#------------------------------------------------------------------------------
# �@ƒGƒlƒ~�[‚ðˆµ‚¤ƒNƒ‰ƒX‚Å‚·�B‚±‚̃Nƒ‰ƒX‚Í Game_Troop ƒNƒ‰ƒX ($game_troop) ‚Ì
# “à•”‚ÅŽg—p‚³‚ê‚Ü‚·�B
#==============================================================================

class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# �œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï�”
#--------------------------------------------------------------------------
attr_accessor :height # ‰æ‘œ‚Ì�‚‚³
attr_accessor :real_x # X�À•W•â�³
attr_accessor :real_y # Y�À•W•â�³
attr_accessor :real_zoom # Šg‘å—¦
#--------------------------------------------------------------------------
# �œ ƒIƒuƒWƒFƒNƒg�‰Šú‰»
# troop_id : ƒgƒ‹�[ƒv ID
# member_index : ƒgƒ‹�[ƒvƒ�ƒ“ƒo�[‚̃Cƒ“ƒfƒbƒNƒX
#--------------------------------------------------------------------------
def initialize(troop_id, member_index)
super()
@troop_id = troop_id
@member_index = member_index
troop = $data_troops[@troop_id]
@enemy_id = troop.members[@member_index].enemy_id
enemy = $data_enemies[@enemy_id]
@battler_name = enemy.battler_name
@battler_hue = enemy.battler_hue
@hp = maxhp
@sp = maxsp
@real_x = 0
@real_y = 0
@real_zoom = 1.0
@fly = 0
enemy.name.sub(/\\[Ff]\[([0-9]+)\]/) {@fly = $1.to_i}
@hidden = troop.members[@member_index].hidden
@immortal = troop.members[@member_index].immortal
end
alias :true_x :screen_x
alias :true_y :screen_y
#--------------------------------------------------------------------------
# �œ ƒoƒgƒ‹‰æ–Ê X �À•W‚̎擾
#--------------------------------------------------------------------------
def screen_x
return 320 + (true_x - 320) * @real_zoom + @real_x
end
#--------------------------------------------------------------------------
# �œ ƒoƒgƒ‹‰æ–Ê Y �À•W‚̎擾
#--------------------------------------------------------------------------
def screen_y
return true_y * @real_zoom + @real_y
end
#--------------------------------------------------------------------------
# �œ ƒoƒgƒ‹‰æ–Ê Z �À•W‚̎擾
#--------------------------------------------------------------------------
def screen_z
return true_y + @fly
end
#--------------------------------------------------------------------------
# �œ ƒoƒgƒ‹‰æ–Ê Šg‘å—¦‚̎擾
#--------------------------------------------------------------------------
def zoom
return ($scene.zoom_rate[1] - $scene.zoom_rate[0]) *
(true_y + @fly) / 320 + $scene.zoom_rate[0]
end
#--------------------------------------------------------------------------
# �œ �UŒ‚—p�Aƒoƒgƒ‹‰æ–Ê X �À•W‚̎擾
#--------------------------------------------------------------------------
def attack_x(z)
return (320 - true_x) * z * 0.75
end
#--------------------------------------------------------------------------
# �œ �UŒ‚—p�Aƒoƒgƒ‹‰æ–Ê Y �À•W‚̎擾
#--------------------------------------------------------------------------
def attack_y(z)
return (160 - (true_y + @fly / 4) * z + @height * zoom * z / 2) * 0.75
end
#--------------------------------------------------------------------------
# �œ ƒAƒNƒVƒ‡ƒ“�ì�¬
#--------------------------------------------------------------------------
def make_action
# ƒJƒŒƒ“ƒgƒAƒNƒVƒ‡ƒ“‚ðƒNƒŠƒA
self.current_action.clear
# “®‚¯‚È‚¢�ê�‡
unless self.inputable?
# ƒ�ƒ\ƒbƒh�I—¹
return
end
# Œ»�Ý—LŒø‚ȃAƒNƒVƒ‡ƒ“‚ð’Š�o
available_actions = []
rating_max = 0
for action in self.actions
# ƒ^�[ƒ“ �ðŒ�Šm”F
n = $game_temp.battle_turn
a = action.condition_turn_a
b = action.condition_turn_b
if (b == 0 and n != a) or
(b > 0 and (n < 1 or n < a or n % b != a % b))
next
end
# HP �ðŒ�Šm”F
if self.hp * 100.0 / self.maxhp > action.condition_hp
next
end
# ƒŒƒxƒ‹ �ðŒ�Šm”F
if $game_party.max_level < action.condition_level
next
end
# ƒXƒCƒbƒ` �ðŒ�Šm”F
switch_id = action.condition_switch_id
if switch_id > 0 and $game_switches[switch_id] == false
next
end
# ƒXƒLƒ‹Žg—p‰Â”\ �ðŒ�Šm”F
if action.kind == 1
unless self.skill_can_use?(action.skill_id)
next
end
end
# �ðŒ�‚ÉŠY“– : ‚±‚̃AƒNƒVƒ‡ƒ“‚ð’ljÁ
available_actions.push(action)
if action.rating > rating_max
rating_max = action.rating
end
end
# �Å‘å‚̃Œ�[ƒeƒBƒ“ƒO’l‚ð 3 ‚Æ‚µ‚Ä�‡Œv‚ðŒvŽZ (0 ˆÈ‰º‚Í�œŠO)
ratings_total = 0
for action in available_actions
if action.rating > rating_max - 3
ratings_total += action.rating - (rating_max - 3)
end
end
# ƒŒ�[ƒeƒBƒ“ƒO‚Ì�‡Œv‚ª 0 ‚Å‚Í‚È‚¢�ê�‡
if ratings_total > 0
# —��”‚ð�ì�¬
value = rand(ratings_total)
# �ì�¬‚µ‚½—��”‚ɑΉž‚·‚é‚à‚Ì‚ðƒJƒŒƒ“ƒgƒAƒNƒVƒ‡ƒ“‚É�Ý’è
for action in available_actions
if action.rating > rating_max - 3
if value < action.rating - (rating_max - 3)
self.current_action.kind = action.kind
self.current_action.basic = action.basic
self.current_action.skill_id = action.skill_id
self.current_action.decide_random_target_for_enemy
return
else
value -= action.rating - (rating_max - 3)
end
end
end
end
end
end

#==============================================================================
# �¡ Game_Party
#------------------------------------------------------------------------------
# �@ƒp�[ƒeƒB‚ðˆµ‚¤ƒNƒ‰ƒX‚Å‚·�BƒS�[ƒ‹ƒh‚âƒAƒCƒeƒ€‚È‚Ç‚Ì�î•ñ‚ªŠÜ‚Ü‚ê‚Ü‚·�B‚±‚̃N
# ƒ‰ƒX‚̃Cƒ“ƒXƒ^ƒ“ƒX‚Í $game_party ‚ÅŽQ�Æ‚³‚ê‚Ü‚·�B
#==============================================================================

class Game_Party
#--------------------------------------------------------------------------
# �œ ‘S–Å”»’è
#--------------------------------------------------------------------------
def all_dead?
# ƒp�[ƒeƒB�l�”‚ª 0 �l‚Ì�ê�‡
if $game_party.actors.size == 0
return false
end
# HP 0 ˆÈ�ã‚̃AƒNƒ^�[‚ªƒp�[ƒeƒB‚É‚¢‚é�ê�‡
for actor in @actors
if actor.hp > 0 or actor.damage.size > 0
return false
end
end
# ‘S–Å
return true
end
end

#==============================================================================
# �¡ Sprite_Battler
#------------------------------------------------------------------------------
# �@ƒoƒgƒ‰�[•\Ž¦—p‚̃Xƒvƒ‰ƒCƒg‚Å‚·�BGame_Battler ƒNƒ‰ƒX‚̃Cƒ“ƒXƒ^ƒ“ƒX‚ðŠÄŽ‹‚µ�A
# ƒXƒvƒ‰ƒCƒg‚Ì�ó‘Ô‚ðŽ©“®“I‚ɕω»‚³‚¹‚Ü‚·�B
#==============================================================================

class Sprite_Battler < RPG::Sprite
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V
#--------------------------------------------------------------------------
def update
super
# ƒoƒgƒ‰�[‚ª nil ‚Ì�ê�‡
if @battler == nil
self.bitmap = nil
loop_animation(nil)
return
end
# ƒtƒ@ƒCƒ‹–¼‚©�F‘Š‚ªŒ»�Ý‚Ì‚à‚̂ƈقȂé�ê�‡
if @battler.battler_name != @battler_name or
@battler.battler_hue != @battler_hue
# ƒrƒbƒgƒ}ƒbƒv‚ðŽæ“¾�A�Ý’è
@battler_name = @battler.battler_name
@battler_hue = @battler.battler_hue
self.bitmap = RPG::Cache.battler(@battler_name, @battler_hue)
@width = bitmap.width
@height = bitmap.height
self.ox = @width / 2
self.oy = @height
if @battler.is_a?(Game_Enemy)
@battler.height = @height
end
# �퓬•s”\‚Ü‚½‚͉B‚ê�ó‘Ô‚È‚ç•s“§–¾“x‚ð 0 ‚É‚·‚é
if @battler.dead? or @battler.hidden
self.opacity = 0
end
end
# ƒAƒjƒ��[ƒVƒ‡ƒ“ ID ‚ªŒ»�Ý‚Ì‚à‚̂ƈقȂé�ê�‡
if @battler.state_animation_id != @state_animation_id
@state_animation_id = @battler.state_animation_id
loop_animation($data_animations[@state_animation_id])
end
# •\Ž¦‚³‚ê‚é‚ׂ«ƒAƒNƒ^�[‚Ì�ê�‡
if @battler.is_a?(Game_Actor) and @battler_visible
# ƒ�ƒCƒ“ƒtƒF�[ƒY‚Å‚È‚¢‚Æ‚«‚Í•s“§–¾“x‚ð‚â‚≺‚°‚é
if $game_temp.battle_main_phase
self.opacity += 3 if self.opacity < 255
else
self.opacity -= 3 if self.opacity > 207
end
end
# –¾–Å
if @battler.blink
blink_on
else
blink_off
end
# •s‰ÂŽ‹‚Ì�ê�‡
unless @battler_visible
# �oŒ»
if not @battler.hidden and not @battler.dead? and
(@battler.damage.size < 2 or @battler.damage_pop.size < 2)
appear
@battler_visible = true
end
end
# ƒ_ƒ��[ƒW
for battler in @battler.damage_pop
if battler[0].class == Array
if battler[0][1] >= 0
$scene.skill_se
else
$scene.levelup_se
end
damage(@battler.damage[battler[0]], false, 2)
else
damage(@battler.damage[battler[0]], @battler.critical[battler[0]])
end
if @battler.damage_sp.include?(battler[0])
damage(@battler.damage_sp[battler[0]],
@battler.critical[battler[0]], 1)
@battler.damage_sp.delete(battler[0])
end
@battler.damage_pop.delete(battler[0])
@battler.damage.delete(battler[0])
@battler.critical.delete(battler[0])
end
# ‰ÂŽ‹‚Ì�ê�‡
if @battler_visible
# “¦‘–
if @battler.hidden
$game_system.se_play($data_system.escape_se)
escape
@battler_visible = false
end
# ”’ƒtƒ‰ƒbƒVƒ…
if @battler.white_flash
whiten
@battler.white_flash = false
end
# ƒAƒjƒ��[ƒVƒ‡ƒ“
unless @battler.animation.empty?
for animation in @battler.animation.reverse
animation($data_animations[animation[0]], animation[1])
@battler.animation.delete(animation)
end
end
# ƒRƒ‰ƒvƒX
if @battler.damage.empty? and @battler.dead?
if $scene.dead_ok?(@battler)
if @battler.is_a?(Game_Enemy)
$game_system.se_play($data_system.enemy_collapse_se)
else
$game_system.se_play($data_system.actor_collapse_se)
end
collapse
@battler_visible = false
end
end
end
# ƒXƒvƒ‰ƒCƒg‚Ì�À•W‚ð�Ý’è
self.x = @battler.screen_x
self.y = @battler.screen_y
self.z = @battler.screen_z
if @battler.is_a?(Game_Enemy)
self.zoom_x = @battler.real_zoom * @battler.zoom
self.zoom_y = @battler.real_zoom * @battler.zoom
end
end
end

#==============================================================================
# �¡ Window_Base
#------------------------------------------------------------------------------
# �@ƒQ�[ƒ€’†‚Ì‚·‚ׂẴEƒBƒ“ƒhƒE‚̃X�[ƒp�[ƒNƒ‰ƒX‚Å‚·�B
#==============================================================================

class Window_Base < Window
#--------------------------------------------------------------------------
# �œ ƒQ�[ƒW‚Ì•`‰æ
#--------------------------------------------------------------------------
def gauge_rect_at(width, height, align3,
color1, color2, color3, color4, color5, color6, color7,
color8, color9, color10, color11, color12, grade1, grade2)
# ˜g•`‰æ
@at_gauge = Bitmap.new(width, height * 5)
@at_gauge.fill_rect(0, 0, width, height, color1)
@at_gauge.fill_rect(1, 1, width - 2, height - 2, color2)
if (align3 == 1 and grade1 == 0) or grade1 > 0
color = color3
color3 = color4
color4 = color
end
if (align3 == 1 and grade2 == 0) or grade2 > 0
color = color5
color5 = color6
color6 = color
color = color7
color7 = color8
color8 = color
color = color9
color9 = color10
color10 = color
color = color11
color11 = color12
color12 = color
end
if align3 == 0
if grade1 == 2
grade1 = 3
end
if grade2 == 2
grade2 = 3
end
end
# ‹óƒQ�[ƒW‚Ì•`‰æ �c‚ɃOƒ‰ƒf�[ƒVƒ‡ƒ“•\Ž¦
@at_gauge.gradation_rect(2, 2, width - 4, height - 4,
color3, color4, grade1)
# ŽÀƒQ�[ƒW‚Ì•`‰æ
@at_gauge.gradation_rect(2, height + 2, width- 4, height - 4,
color5, color6, grade2)
@at_gauge.gradation_rect(2, height * 2 + 2, width- 4, height - 4,
color7, color8, grade2)
@at_gauge.gradation_rect(2, height * 3 + 2, width- 4, height - 4,
color9, color10, grade2)
@at_gauge.gradation_rect(2, height * 4 + 2, width- 4, height - 4,
color11, color12, grade2)
end
end

#==============================================================================
# �¡ Window_Help
#------------------------------------------------------------------------------
# �@ƒXƒLƒ‹‚âƒAƒCƒeƒ€‚Ì�à–¾�AƒAƒNƒ^�[‚̃Xƒe�[ƒ^ƒX‚È‚Ç‚ð•\Ž¦‚·‚éƒEƒBƒ“ƒhƒE‚Å‚·�B
#==============================================================================

class Window_Help < Window_Base
#--------------------------------------------------------------------------
# �œ ƒGƒlƒ~�[�Ý’è
# enemy : –¼‘O‚ƃXƒe�[ƒg‚ð•\Ž¦‚·‚éƒGƒlƒ~�[
#--------------------------------------------------------------------------
def set_enemy(enemy)
text = enemy.name.sub(/\\[Ff]\[([0-9]+)\]/) {""}
state_text = make_battler_state_text(enemy, 112, false)
if state_text != ""
text += " " + state_text
end
set_text(text, 1)
end
end

#==============================================================================
# �¡ Window_BattleStatus
#------------------------------------------------------------------------------
# �@ƒoƒgƒ‹‰æ–ʂŃp�[ƒeƒBƒ�ƒ“ƒo�[‚̃Xƒe�[ƒ^ƒX‚ð•\Ž¦‚·‚éƒEƒBƒ“ƒhƒE‚Å‚·�B
#==============================================================================

class Window_BattleStatus < Window_Base
#--------------------------------------------------------------------------
# �œ ƒIƒuƒWƒFƒNƒg�‰Šú‰»
#--------------------------------------------------------------------------
def initialize
x = (4 - $game_party.actors.size) * 80
width = $game_party.actors.size * 160
super(x, 320, width, 160)
self.back_opacity = 160
@actor_window = []
for i in 0...$game_party.actors.size
@actor_window.push(Window_ActorStatus.new(i, x + i * 160))
end
@level_up_flags = [false, false, false, false]
refresh
end
#--------------------------------------------------------------------------
# �œ ‰ð•ú
#--------------------------------------------------------------------------
def dispose
for window in @actor_window
window.dispose
end
super
end
#--------------------------------------------------------------------------
# �œ ƒŠƒtƒŒƒbƒVƒ…
#--------------------------------------------------------------------------
def refresh(number = 0)
if number == 0
cnt = 0
for window in @actor_window
window.refresh(@level_up_flags[cnt])
cnt += 1
end
else
@actor_window[number - 1].refresh(@level_up_flags[number - 1])
end
end
#--------------------------------------------------------------------------
# �œ ATƒQ�[ƒWƒŠƒtƒŒƒbƒVƒ…
#--------------------------------------------------------------------------
def at_refresh(number = 0)
if number == 0
for window in @actor_window
window.at_refresh
end
else
@actor_window[number - 1].at_refresh
end
end
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V
#--------------------------------------------------------------------------
def update
super
if self.x != (4 - $game_party.actors.size) * 80
self.x = (4 - $game_party.actors.size) * 80
self.width = $game_party.actors.size * 160
for window in @actor_window
window.dispose
end
@actor_window = []
for i in 0...$game_party.actors.size
@actor_window.push(Window_ActorStatus.new(i, x + i * 160))
end
refresh
end
for window in @actor_window
window.update
end
end
end

#==============================================================================
# �¡ Window_ActorStatus
#------------------------------------------------------------------------------
# �@ƒoƒgƒ‹‰æ–ʂŃp�[ƒeƒBƒ�ƒ“ƒo�[‚̃Xƒe�[ƒ^ƒX‚ð‚»‚ê‚¼‚ê•\Ž¦‚·‚éƒEƒBƒ“ƒhƒE‚Å‚·�B
#==============================================================================

class Window_ActorStatus < Window_Base
#--------------------------------------------------------------------------
# �œ ƒIƒuƒWƒFƒNƒg�‰Šú‰»
#--------------------------------------------------------------------------
def initialize(id, x)
@actor_num = id
super(x, 320, 160, 160)
self.contents = Bitmap.new(width - 32, height - 32)
self.opacity = 0
self.back_opacity = 0
actor = $game_party.actors[@actor_num]
@actor_nm = actor.name
@actor_mhp = actor.maxhp
@actor_msp = actor.maxsp
@actor_hp = actor.hp
@actor_sp = actor.sp
@actor_st = make_battler_state_text(actor, 120, true)
@status_window = []
for i in 0...5
@status_window.push(Window_DetailsStatus.new(actor, i, x))
end
refresh(false)
end
#--------------------------------------------------------------------------
# �œ ‰ð•ú
#--------------------------------------------------------------------------
def dispose
for i in 0...5
@status_window[i].dispose
end
super
end
#--------------------------------------------------------------------------
# �œ ƒŠƒtƒŒƒbƒVƒ…
#--------------------------------------------------------------------------
def refresh(level_up_flags)
self.contents.clear
actor = $game_party.actors[@actor_num]
@status_window[0].refresh(actor) if @actor_nm != actor.name
@status_window[1].refresh(actor) if
@actor_mhp != actor.maxhp or @actor_hp != actor.hp
@status_window[2].refresh(actor) if
@actor_msp != actor.maxsp or @actor_sp != actor.sp
@status_window[3].refresh(actor, level_up_flags) if
@actor_st != make_battler_state_text(actor, 120, true) or level_up_flags
@actor_nm = actor.name
@actor_mhp = actor.maxhp
@actor_msp = actor.maxsp
@actor_hp = actor.hp
@actor_sp = actor.sp
@actor_st = make_battler_state_text(actor, 120, true)
end
#--------------------------------------------------------------------------
# �œ ATƒQ�[ƒWƒŠƒtƒŒƒbƒVƒ…
#--------------------------------------------------------------------------
def at_refresh
@status_window[4].refresh($game_party.actors[@actor_num])
end
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V
#--------------------------------------------------------------------------
def update
for window in @status_window
window.update
end
end
end

#==============================================================================
# �¡ Window_DetailsStatus
#------------------------------------------------------------------------------
# �@ƒoƒgƒ‹‰æ–ʂŃAƒNƒ^�[‚̃Xƒe�[ƒ^ƒX‚ðŒÂ�X‚É•\Ž¦‚·‚éƒEƒBƒ“ƒhƒE‚Å‚·�B
#==============================================================================

class Window_DetailsStatus < Window_Base
#--------------------------------------------------------------------------
# �œ ƒIƒuƒWƒFƒNƒg�‰Šú‰»
#--------------------------------------------------------------------------
def initialize(actor, id, x)
@status_id = id
super(x, 320 + id * 26, 160, 64)
self.contents = Bitmap.new(width - 32, height - 32)
self.opacity = 0
self.back_opacity = 0
refresh(actor, false)
end
#--------------------------------------------------------------------------
# �œ ‰ð•ú
#--------------------------------------------------------------------------
def dispose
super
end
#--------------------------------------------------------------------------
# �œ ƒŠƒtƒŒƒbƒVƒ…
#--------------------------------------------------------------------------
def refresh(actor, level_up_flags = false)
self.contents.clear
case @status_id
when 0
draw_actor_name(actor, 4, 0)
when 1
draw_actor_hp(actor, 4, 0, 120)
when 2
draw_actor_sp(actor, 4, 0, 120)
when 3
if level_up_flags
self.contents.font.color = normal_color
self.contents.draw_text(4, 0, 120, 32, "LEVEL UP!")
else
draw_actor_state(actor, 4, 0)
end
when 4
draw_actor_atg(actor, 4, 0, 120)
end
end
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V
#--------------------------------------------------------------------------
def update
# ƒ�ƒCƒ“ƒtƒF�[ƒY‚Ì‚Æ‚«‚Í•s“§–¾“x‚ð‚â‚≺‚°‚é
if $game_temp.battle_main_phase
self.contents_opacity -= 4 if self.contents_opacity > 191
else
self.contents_opacity += 4 if self.contents_opacity < 255
end
end
end

#==============================================================================
# �¡ Arrow_Base
#------------------------------------------------------------------------------
# �@ƒoƒgƒ‹‰æ–Ê‚ÅŽg—p‚·‚éƒAƒ��[ƒJ�[ƒ\ƒ‹•\Ž¦—p‚̃Xƒvƒ‰ƒCƒg‚Å‚·�B‚±‚̃Nƒ‰ƒX‚Í
# Arrow_Enemy ƒNƒ‰ƒX‚Æ Arrow_Actor ƒNƒ‰ƒX‚̃X�[ƒp�[ƒNƒ‰ƒX‚Æ‚µ‚ÄŽg—p‚³‚ê‚Ü‚·�B
#==============================================================================

class Arrow_Base < Sprite
#--------------------------------------------------------------------------
# �œ ƒIƒuƒWƒFƒNƒg�‰Šú‰»
# viewport : ƒrƒ…�[ƒ|�[ƒg
#--------------------------------------------------------------------------
def initialize(viewport)
super(viewport)
self.bitmap = RPG::Cache.windowskin($game_system.windowskin_name)
self.ox = 16
self.oy = 32
self.z = 2500
@blink_count = 0
@index = 0
@help_window = nil
update
end
end

#==============================================================================
# �¡ Arrow_Enemy
#------------------------------------------------------------------------------
# �@ƒGƒlƒ~�[‚ð‘I‘ð‚³‚¹‚邽‚߂̃Aƒ��[ƒJ�[ƒ\ƒ‹‚Å‚·�B‚±‚̃Nƒ‰ƒX‚Í Arrow_Base ƒNƒ‰
# ƒX‚ðŒp�³‚µ‚Ü‚·�B
#==============================================================================

class Arrow_Enemy < Arrow_Base
#--------------------------------------------------------------------------
# �œ ƒtƒŒ�[ƒ€�X�V
#--------------------------------------------------------------------------
def update
super
# ‘¶�Ý‚µ‚È‚¢ƒGƒlƒ~�[‚ðŽw‚µ‚Ä‚¢‚½‚ç”ò‚΂·
$game_troop.enemies.size.times do
break if self.enemy.exist?
@index += 1
@index %= $game_troop.enemies.size
end
# ƒJ�[ƒ\ƒ‹‰E
if Input.repeat?(Input::RIGHT)
$game_system.se_play($data_system.cursor_se)
$game_troop.enemies.size.times do
@index += 1
@index %= $game_troop.enemies.size
break if self.enemy.exist?
end
$scene.camera = "select"
zoom = 1 / self.enemy.zoom
$scene.spriteset.screen_target(self.enemy.attack_x(zoom) * 0.75,
self.enemy.attack_y(zoom) * 0.75, zoom)
end
# ƒJ�[ƒ\ƒ‹�¶
if Input.repeat?(Input::LEFT)
$game_system.se_play($data_system.cursor_se)
$game_troop.enemies.size.times do
@index += $game_troop.enemies.size - 1
@index %= $game_troop.enemies.size
break if self.enemy.exist?
end
$scene.camera = "select"
zoom = 1 / self.enemy.zoom
$scene.spriteset.screen_target(self.enemy.attack_x(zoom) * 0.75,
self.enemy.attack_y(zoom) * 0.75, zoom)
end
# ƒXƒvƒ‰ƒCƒg‚Ì�À•W‚ð�Ý’è
if self.enemy != nil
self.x = self.enemy.screen_x
self.y = self.enemy.screen_y
end
end
end

#==============================================================================
# �¡ Interpreter
#------------------------------------------------------------------------------
# �@ƒCƒxƒ“ƒgƒRƒ}ƒ“ƒh‚ðŽÀ�s‚·‚éƒCƒ“ƒ^ƒvƒŠƒ^‚Å‚·�B‚±‚̃Nƒ‰ƒX‚Í Game_System ƒNƒ‰
# ƒX‚â Game_Event ƒNƒ‰ƒX‚Ì“à•”‚ÅŽg—p‚³‚ê‚Ü‚·�B
#==============================================================================

class Interpreter
#--------------------------------------------------------------------------
# �œ ƒAƒNƒ^�[‚Ì“ü‚ê‘Ö‚¦
#--------------------------------------------------------------------------
def command_129
# ƒAƒNƒ^�[‚ðŽæ“¾
actor = $game_actors[@parameters[0]]
# ƒAƒNƒ^�[‚ª—LŒø‚Ì�ê�‡
if actor != nil
# ‘€�ì‚Å•ªŠò
if @parameters[1] == 0
if @parameters[2] == 1
$game_actors[@parameters[0]].setup(@parameters[0])
end
$game_party.add_actor(@parameters[0])
if $game_temp.in_battle
$game_actors[@parameters[0]].at = 0
$game_actors[@parameters[0]].atp = 0
$scene.spell_reset($game_actors[@parameters[0]])
$game_actors[@parameters[0]].damage_pop = {}
$game_actors[@parameters[0]].damage = {}
$game_actors[@parameters[0]].damage_sp = {}
$game_actors[@parameters[0]].critical = {}
$game_actors[@parameters[0]].recover_hp = {}
$game_actors[@parameters[0]].recover_sp = {}
$game_actors[@parameters[0]].state_p = {}
$game_actors[@parameters[0]].state_m = {}
$game_actors[@parameters[0]].animation = []
end
else
$game_party.remove_actor(@parameters[0])
end
end
if $game_temp.in_battle
$scene.status_window.update
end
# Œp‘±
return true
end
#--------------------------------------------------------------------------
# �œ HP ‚Ì‘�Œ¸
#--------------------------------------------------------------------------
alias :command_311_rtab :command_311
def command_311
command_311_rtab
if $game_temp.in_battle
$scene.status_window.refresh
end
end
#--------------------------------------------------------------------------
# �œ SP ‚Ì‘�Œ¸
#--------------------------------------------------------------------------
alias :command_312_rtab :command_312
def command_312
command_312_rtab
if $game_temp.in_battle
$scene.status_window.refresh
end
end
#--------------------------------------------------------------------------
# �œ ƒXƒe�[ƒg‚Ì•Ï�X
#--------------------------------------------------------------------------
alias :command_313_rtab :command_313
def command_313
command_313_rtab
if $game_temp.in_battle
$scene.status_window.refresh
end
end
#--------------------------------------------------------------------------
# �œ ‘S‰ñ•œ
#--------------------------------------------------------------------------
alias :command_314_rtab :command_314
def command_314
command_314_rtab
if $game_temp.in_battle
$scene.status_window.refresh
end
end
#--------------------------------------------------------------------------
# �œ EXP ‚Ì‘�Œ¸
#--------------------------------------------------------------------------
alias :command_315_rtab :command_315
def command_315
command_315_rtab
if $game_temp.in_battle
$scene.status_window.refresh
end
end
#--------------------------------------------------------------------------
# �œ ƒŒƒxƒ‹‚Ì‘�Œ¸
#--------------------------------------------------------------------------
alias :command_316_rtab :command_316
def command_316
command_316_rtab
if $game_temp.in_battle
$scene.status_window.refresh
end
end
#--------------------------------------------------------------------------
# �œ ƒpƒ‰ƒ��[ƒ^‚Ì‘�Œ¸
#--------------------------------------------------------------------------
alias :command_317_rtab :command_317
def command_317
command_317_rtab
if $game_temp.in_battle
$scene.status_window.refresh
end
end
#--------------------------------------------------------------------------
# �œ ‘•”õ‚Ì•Ï�X
#--------------------------------------------------------------------------
alias :command_319_rtab :command_319
def command_319
command_319_rtab
if $game_temp.in_battle
$scene.status_window.refresh
end
end
#--------------------------------------------------------------------------
# �œ ƒAƒNƒ^�[‚Ì–¼‘O•Ï�X
#--------------------------------------------------------------------------
alias :command_320_rtab :command_320
def command_320
command_320_rtab
if $game_temp.in_battle
$scene.status_window.refresh
end
end
#--------------------------------------------------------------------------
# �œ ƒAƒNƒ^�[‚̃Nƒ‰ƒX•Ï�X
#--------------------------------------------------------------------------
alias :command_321_rtab :command_321
def command_321
command_321_rtab
if $game_temp.in_battle
$scene.status_window.refresh
end
end
#--------------------------------------------------------------------------
# �œ ƒAƒjƒ��[ƒVƒ‡ƒ“‚Ì•\Ž¦
#--------------------------------------------------------------------------
def command_337
# ƒCƒeƒŒ�[ƒ^‚Å�ˆ—�
iterate_battler(@parameters[0], @parameters[1]) do |battler|
# ƒoƒgƒ‰�[‚ª‘¶�Ý‚·‚é�ê�‡
if battler.exist?
# ƒAƒjƒ��[ƒVƒ‡ƒ“ ID ‚ð�Ý’è
battler.animation.push([@parameters[2], true])
end
end
# Œp‘±
return true
end
#--------------------------------------------------------------------------
# �œ ƒ_ƒ��[ƒW‚Ì�ˆ—�
#--------------------------------------------------------------------------
def command_338
# ‘€�ì‚·‚é’l‚ðŽæ“¾
value = operate_value(0, @parameters[2], @parameters[3])
# ƒCƒeƒŒ�[ƒ^‚Å�ˆ—�
iterate_battler(@parameters[0], @parameters[1]) do |battler|
# ƒoƒgƒ‰�[‚ª‘¶�Ý‚·‚é�ê�‡
if battler.exist?
# HP ‚ð•Ï�X
battler.hp -= value
# �퓬’†‚È‚ç
if $game_temp.in_battle
# ƒ_ƒ��[ƒW‚ð�Ý’è
battler.damage["event"] = value
battler.damage_pop["event"] = true
end
end
end
if $game_temp.in_battle
$scene.status_window.refresh
end
# Œp‘±
return true
end
#--------------------------------------------------------------------------
# �œ ƒAƒNƒVƒ‡ƒ“‚Ì‹­�§
#--------------------------------------------------------------------------
def command_339
# �퓬’†‚Å‚È‚¯‚ê‚Ζ³Ž‹
unless $game_temp.in_battle
return true
end
# ƒ^�[ƒ“�”‚ª 0 ‚È‚ç–³Ž‹
if $game_temp.battle_turn == 0
return true
end
# ƒCƒeƒŒ�[ƒ^‚Å�ˆ—� (•Ö‹X“I‚È‚à‚Ì‚Å�A•¡�”‚ɂȂ邱‚Æ‚Í‚È‚¢)
iterate_battler(@parameters[0], @parameters[1]) do |battler|
# ƒoƒgƒ‰�[‚ª‘¶�Ý‚·‚é�ê�‡
if battler.exist?
# ƒAƒNƒVƒ‡ƒ“‚ð�Ý’è
battler.current_action.force_kind = @parameters[2]
if battler.current_action.force_kind == 0
battler.current_action.force_basic = @parameters[3]
else
battler.current_action.force_skill_id = @parameters[3]
end
# �s“®‘Î�Û‚ð�Ý’è
if @parameters[4] == -2
if battler.is_a?(Game_Enemy)
battler.current_action.decide_last_target_for_enemy
else
battler.current_action.decide_last_target_for_actor
end
elsif @parameters[4] == -1
if battler.is_a?(Game_Enemy)
battler.current_action.decide_random_target_for_enemy
else
battler.current_action.decide_random_target_for_actor
end
elsif @parameters[4] >= 0
battler.current_action.target_index = @parameters[4]
end
# ƒAƒNƒVƒ‡ƒ“‚ª—LŒø‚©‚ [‚·‚®‚ÉŽÀ�s] ‚Ì�ê�‡
if battler.current_action.valid? and @parameters[5] == 1
# ‹­�§‘Î�ۂ̃oƒgƒ‰�[‚ð�Ý’è
$game_temp.forcing_battler = battler
# ƒCƒ“ƒfƒbƒNƒX‚ð�i‚ß‚é
@index += 1
# �I—¹
return false
elsif battler.current_action.valid? and @parameters[5] == 0
battler.current_action.forcing = true
end
end
end
# Œp‘±
return true
end
end

#==============================================================================
# �¡ Spriteƒ‚ƒWƒ…�[ƒ‹
#------------------------------------------------------------------------------
# �@ƒAƒjƒ��[ƒVƒ‡ƒ“‚ÌŠÇ—�‚ð�s‚¤ƒ‚ƒWƒ…�[ƒ‹‚Å‚·�B
#==============================================================================

module RPG
class Sprite < ::Sprite
def initialize(viewport = nil)
super(viewport)
@_whiten_duration = 0
@_appear_duration = 0
@_escape_duration = 0
@_collapse_duration = 0
@_damage = []
@_animation = []
@_animation_duration = 0
@_blink = false
end
def damage(value, critical, type = 0)
if value.is_a?(Numeric)
damage_string = value.abs.to_s
else
damage_string = value.to_s
end
bitmap = Bitmap.new(160, 4 )
bitmap.font.name = "Arial Black"
bitmap.font.size = 32
bitmap.font.color.set(0, 0, 0)
bitmap.draw_text(-1, 12-1, 160, 36, damage_string, 1)
bitmap.draw_text(+1, 12-1, 160, 36, damage_string, 1)
bitmap.draw_text(-1, 12+1, 160, 36, damage_string, 1)
bitmap.draw_text(+1, 12+1, 160, 36, damage_string, 1)
if value.is_a?(Numeric) and value < 0
if type == 0
bitmap.font.color.set(176, 255, 144)
else
bitmap.font.color.set(176, 144, 255)
end
else
if type == 0
bitmap.font.color.set(255, 255, 255)
else
bitmap.font.color.set(255, 176, 144)
end
end
if type == 2
bitmap.font.color.set(255, 224, 128)
end
bitmap.draw_text(0, 12, 160, 36, damage_string, 1)
if critical
string = "CRITICAL"
bitmap.font.size = 20
bitmap.font.color.set(0, 0, 0)
bitmap.draw_text(-1, -1, 160, 20, string, 1)
bitmap.draw_text(+1, -1, 160, 20, string, 1)
bitmap.draw_text(-1, +1, 160, 20, string, 1)
bitmap.draw_text(+1, +1, 160, 20, string, 1)
bitmap.font.color.set(255, 255, 255)
bitmap.draw_text(0, 0, 160, 20, string, 1)
end
num = @_damage.size
if type != 2
@_damage.push([::Sprite.new, 40, 0, rand(40) - 20, rand(30) + 50])
else
@_damage.push([::Sprite.new, 40, 0, rand(20) - 10, rand(20) + 60])
end
@_damage[num][0].bitmap = bitmap
@_damage[num][0].ox = 80 + self.viewport.ox
@_damage[num][0].oy = 20 + self.viewport.oy
if self.battler.is_a?(Game_Actor)
@_damage[num][0].x = self.x
@_damage[num][0].y = self.y - self.oy / 2
else
@_damage[num][0].x = self.x + self.viewport.rect.x -
self.ox + self.src_rect.width / 2
@_damage[num][0].y = self.y - self.oy * self.zoom_y / 2 +
self.viewport.rect.y
@_damage[num][0].zoom_x = self.zoom_x
@_damage[num][0].zoom_y = self.zoom_y
@_damage[num][0].z = 3000
end
end
def animation(animation, hit)
return if animation == nil
num = @_animation.size
@_animation.push([animation, hit, animation.frame_max, []])
bitmap = RPG::Cache.animation(animation.animation_name,
animation.animation_hue)
if @@_reference_count.include?(bitmap)
@@_reference_count[bitmap] += 1
else
@@_reference_count[bitmap] = 1
end
if @_animation[num][0] != 3 or not @@_animations.include?(animation)
for i in 0..15
sprite = ::Sprite.new
sprite.bitmap = bitmap
sprite.visible = false
@_animation[num][3].push(sprite)
end
unless @@_animations.include?(animation)
@@_animations.push(animation)
end
end
update_animation(@_animation[num])
end
def loop_animation(animation)
return if animation == @_loop_animation
dispose_loop_animation
@_loop_animation = animation
return if @_loop_animation == nil
@_loop_animation_index = 0
animation_name = @_loop_animation.animation_name
animation_hue = @_loop_animation.animation_hue
bitmap = RPG::Cache.animation(animation_name, animation_hue)
if @@_reference_count.include?(bitmap)
@@_reference_count[bitmap] += 1
else
@@_reference_count[bitmap] = 1
end
@_loop_animation_sprites = []
for i in 0..15
sprite = ::Sprite.new
sprite.bitmap = bitmap
sprite.visible = false
@_loop_animation_sprites.push(sprite)
end
update_loop_animation
end
def dispose_damage
for damage in @_damage.reverse
damage[0].bitmap.dispose
damage[0].dispose
@_damage.delete(damage)
end
end
def dispose_animation
for anime in @_animation.reverse
sprite = anime[3][0]
if sprite != nil
@@_reference_count[sprite.bitmap] -= 1
if @@_reference_count[sprite.bitmap] == 0
sprite.bitmap.dispose
end
end
for sprite in anime[3]
sprite.dispose
end
@_animation.delete(anime)
end
end
def effect?
@_whiten_duration > 0 or
@_appear_duration > 0 or
@_escape_duration > 0 or
@_collapse_duration > 0 or
@_damage.size == 0 or
@_animation.size == 0
end
def update
super
if @_whiten_duration > 0
@_whiten_duration -= 1
self.color.alpha = 128 - (16 - @_whiten_duration) * 10
end
if @_appear_duration > 0
@_appear_duration -= 1
self.opacity = (16 - @_appear_duration) * 16
end
if @_escape_duration > 0
@_escape_duration -= 1
self.opacity = 256 - (32 - @_escape_duration) * 10
end
if @_collapse_duration > 0
@_collapse_duration -= 1
self.opacity = 256 - (48 - @_collapse_duration) * 6
end
for damage in @_damage
if damage[1] > 0
damage[1] -= 1
damage[4] -= 3
damage[2] -= damage[4]
if self.battler.is_a?(Game_Actor)
damage[0].x = self.x + (40 - damage[1]) * damage[3] / 10
damage[0].y = self.y - self.oy / 2 + damage[2] / 10
else
damage[0].x = self.x + self.viewport.rect.x -
self.ox + self.src_rect.width / 2 +
(40 - damage[1]) * damage[3] / 10
damage[0].y = self.y - self.oy * self.zoom_y / 2 +
self.viewport.rect.y + damage[2] / 10
damage[0].zoom_x = self.zoom_x
damage[0].zoom_y = self.zoom_y
end
damage[0].z = 2960 + damage[1]
damage[0].opacity = 256 - (12 - damage[1]) * 32
if damage[1] == 0
damage[0].bitmap.dispose
damage[0].dispose
@_damage.delete(damage)
end
end
end
for anime in @_animation
if (Graphics.frame_count % 2 == 0)
anime[2] -= 1
update_animation(anime)
end
end
if @_loop_animation != nil and (Graphics.frame_count % 2 == 0)
update_loop_animation
@_loop_animation_index += 1
@_loop_animation_index %= @_loop_animation.frame_max
end
if @_blink
@_blink_count = (@_blink_count + 1) % 32
if @_blink_count < 16
alpha = (16 - @_blink_count) * 6
else
alpha = (@_blink_count - 16) * 6
end
self.color.set(255, 255, 255, alpha)
end
@@_animations.clear
end
def update_animation(anime)
if anime[2] > 0
frame_index = anime[0].frame_max - anime[2]
cell_data = anime[0].frames[frame_index].cell_data
position = anime[0].position
animation_set_sprites(anime[3], cell_data, position)
for timing in anime[0].timings
if timing.frame == frame_index
animation_process_timing(timing, anime[1])
end
end
else
@@_reference_count[anime[3][0].bitmap] -= 1
if @@_reference_count[anime[3][0].bitmap] == 0
anime[3][0].bitmap.dispose
end
for sprite in anime[3]
sprite.dispose
end
@_animation.delete(anime)
end
end
def animation_set_sprites(sprites, cell_data, position)
for i in 0..15
sprite = sprites[i]
pattern = cell_data[i, 0]
if sprite == nil or pattern == nil or pattern == -1
sprite.visible = false if sprite != nil
next
end
sprite.visible = true
sprite.src_rect.set(pattern % 5 * 192, pattern / 5 * 192, 192, 192)
if position == 3
if self.viewport != nil
sprite.x = self.viewport.rect.width / 2
if $game_temp.in_battle and self.battler.is_a?(Game_Enemy)
sprite.y = self.viewport.rect.height - 320
else
sprite.y = self.viewport.rect.height - 160
end
else
sprite.x = 320
sprite.y = 240
end
else
sprite.x = self.x + self.viewport.rect.x -
self.ox + self.src_rect.width / 2
if $game_temp.in_battle and self.battler.is_a?(Game_Enemy)
sprite.y = self.y - self.oy * self.zoom_y / 2 +
self.viewport.rect.y
if position == 0
sprite.y -= self.src_rect.height * self.zoom_y / 4
elsif position == 2
sprite.y += self.src_rect.height * self.zoom_y / 4
end
else
sprite.y = self.y + self.viewport.rect.y -
self.oy + self.src_rect.height / 2
sprite.y -= self.src_rect.height / 4 if position == 0
sprite.y += self.src_rect.height / 4 if position == 2
end
end
sprite.x += cell_data[i, 1]
sprite.y += cell_data[i, 2]
sprite.z = 2000
sprite.ox = 96
sprite.oy = 96
sprite.zoom_x = cell_data[i, 3] / 100.0
sprite.zoom_y = cell_data[i, 3] / 100.0
if position != 3
sprite.zoom_x *= self.zoom_x
sprite.zoom_y *= self.zoom_y
end
sprite.angle = cell_data[i, 4]
sprite.mirror = (cell_data[i, 5] == 1)
sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
sprite.blend_type = cell_data[i, 7]
end
end
def x=(x)
sx = x - self.x
if sx != 0
for anime in @_animation
if anime[3] != nil
for i in 0..15
anime[3][i].x += sx
end
end
end
if @_loop_animation_sprites != nil
for i in 0..15
@_loop_animation_sprites[i].x += sx
end
end
end
super
end
def y=(y)
sy = y - self.y
if sy != 0
for anime in @_animation
if anime[3] != nil
for i in 0..15
anime[3][i].y += sy
end
end
end
if @_loop_animation_sprites != nil
for i in 0..15
@_loop_animation_sprites[i].y += sy
end
end
end
super
end
end
end

#------------------------------------------------------------------------------
# �@BitmapƒNƒ‰ƒX‚É�V‚½‚È‹@”\‚ð’ljÁ‚µ‚Ü‚·�B
#==============================================================================

class Bitmap
#--------------------------------------------------------------------------
# �œ ‹éŒ`‚ðƒOƒ‰ƒf�[ƒVƒ‡ƒ“•\Ž¦
# color1 : ƒXƒ^�[ƒgƒJƒ‰�[
# color2 : ƒGƒ“ƒhƒJƒ‰�[
# align : 0:‰¡‚ɃOƒ‰ƒf�[ƒVƒ‡ƒ“
# 1:�c‚ɃOƒ‰ƒf�[ƒVƒ‡ƒ“
# 2:ŽÎ‚߂ɃOƒ‰ƒf�[ƒVƒ‡ƒ“�iŒƒ�d‚ɂ‚«’�ˆÓ�j
#--------------------------------------------------------------------------
def gradation_rect(x, y, width, height, color1, color2, align = 0)
if align == 0
for i in x...x + width
red = color1.red + (color2.red - color1.red) * (i - x) / (width - 1)
green = color1.green +
(color2.green - color1.green) * (i - x) / (width - 1)
blue = color1.blue +
(color2.blue - color1.blue) * (i - x) / (width - 1)
alpha = color1.alpha +
(color2.alpha - color1.alpha) * (i - x) / (width - 1)
color = Color.new(red, green, blue, alpha)
fill_rect(i, y, 1, height, color)
end
elsif align == 1
for i in y...y + height
red = color1.red +
(color2.red - color1.red) * (i - y) / (height - 1)
green = color1.green +
(color2.green - color1.green) * (i - y) / (height - 1)
blue = color1.blue +
(color2.blue - color1.blue) * (i - y) / (height - 1)
alpha = color1.alpha +
(color2.alpha - color1.alpha) * (i - y) / (height - 1)
color = Color.new(red, green, blue, alpha)
fill_rect(x, i, width, 1, color)
end
elsif align == 2
for i in x...x + width
for j in y...y + height
red = color1.red + (color2.red - color1.red) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
green = color1.green + (color2.green - color1.green) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
blue = color1.blue + (color2.blue - color1.blue) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
alpha = color1.alpha + (color2.alpha - color1.alpha) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
color = Color.new(red, green, blue, alpha)
set_pixel(i, j, color)
end
end
elsif align == 3
for i in x...x + width
for j in y...y + height
red = color1.red + (color2.red - color1.red) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
green = color1.green + (color2.green - color1.green) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
blue = color1.blue + (color2.blue - color1.blue) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
alpha = color1.alpha + (color2.alpha - color1.alpha) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
color = Color.new(red, green, blue, alpha)
set_pixel(i, j, color)
end
end
end
end
end