Le forum de la production "Warrior Games Production" Index du Forum
S’enregistrerRechercherFAQMembresGroupesConnexion
Combats relookée

 
Répondre au sujet    Le forum de la production "Warrior Games Production" Index du Forum » Vos Projets » Scripts Sujet précédent
Sujet suivant
Combats relookée
Auteur Message
nosferatus
Maker

Hors ligne

Inscrit le: 01 Avr 2008
Messages: 99
Localisation: france
Masculin Cancer (21juin-23juil) 狗 Chien

Message Combats relookée Répondre en citant
titre: Combat avec zoom relooké

Description: avoir des combat relooké

créateur:cowghell

testé et aprouvé

Supprimer le script New Battle, et au dessus de Main, insérez ces deux scripts.  (trés long)

Le premier, nommé le "Jauge" (ou"Gauge", mais je pense plutot que c'est un vieux makeur pourri qui à fait une sale phote d'aurtaugrophe)
Edit : Non non, il faut bel et bien écrire Gauge, avec un "G" attention ^^)


 

 
Code:
# ”z•zŒ³EƒTƒ|[ƒgURL
# [url=http://members.jcom.home.ne.jp/cogwheel/][color=#006699]http://members.jcom.home.ne.jp/cogwheel/[/color][/url]

#===================
# ¡ 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 now_exp
return @exp - @exp_list[@level]
end
def next_exp
return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
end
end

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

class Window_Base < Window
#----------------------------------
# œ HP ƒQ[ƒW‚Ì•`‰æ
#----------------------------------
# ƒIƒŠƒWƒiƒ‹‚ÌHP•`‰æ‚ð draw_actor_hp_original ‚Æ–Œ‘O•ÏX
alias :draw_actor_hp_original :draw_actor_hp
def draw_actor_hp(actor, x, y, width = 144)
# •Ï”rate‚É Œ»Ý‚ÌHP/MHP‚ð‘ã“ü
if actor.maxhp != 0
rate = actor.hp.to_f / actor.maxhp
else
rate = 0
end
# 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 = 25
plus_width = 0
rate_width = 100
height = 10
align1 = 1
align2 = 2
align3 = 0
# ƒOƒ‰ƒf[ƒVƒ‡ƒ“Ý’è grade1:‹óƒQ[ƒW grade2:ŽÀƒQ[ƒW
# (0:‰¡‚ɃOƒ‰ƒf[ƒVƒ‡ƒ“ 1:c‚ɃOƒ‰ƒf[ƒVƒ‡ƒ“ 2:ŽÎ‚߂ɃOƒ‰ƒf[ƒVƒ‡ƒ“(Œƒd)j
grade1 = 1
grade2 = 0
# FÝ’èBcolor1:ŠO˜gCcolor2:’†˜g
# color3:‹óƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor4:‹óƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
# color5:ŽÀƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor6:ŽÀƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 255, 192, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(64, 0, 0, 192)
color5 = Color.new(80 - 24 * rate, 80 * rate, 14 * rate, 192)
color6 = Color.new(240 - 72 * rate, 240 * rate, 62 * rate, 192)
# •Ï”sp‚É•`‰æ‚·‚éƒQ[ƒW‚Ì•‚ð‘ã“ü
if actor.maxhp != 0
hp = (width + plus_width) * actor.hp * rate_width / 100 / actor.maxhp
else
hp = 0
end
# ƒQ[ƒW‚Ì•`‰æ
gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
width, plus_width + width * rate_width / 100,
height, hp, align1, align2, align3,
color1, color2, color3, color4, color5, color6, grade1, grade2)
# ƒIƒŠƒWƒiƒ‹‚ÌHP•`‰æˆ—‚ðŒÄ‚яo‚µ
draw_actor_hp_original(actor, x, y, width)
end
#----------------------------------
# œ SP ƒQ[ƒW‚Ì•`‰æ
#----------------------------------
# ƒIƒŠƒWƒiƒ‹‚ÌSP•`‰æ‚ð draw_actor_sp_original ‚Æ–Œ‘O•ÏX
alias :draw_actor_sp_original :draw_actor_sp
def draw_actor_sp(actor, x, y, width = 144)
# •Ï”rate‚É Œ»Ý‚ÌSP/MSP‚ð‘ã“ü
if actor.maxsp != 0
rate = actor.sp.to_f / actor.maxsp
else
rate = 1
end
# 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 = 25
plus_width = 0
rate_width = 100
height = 10
align1 = 1
align2 = 2
align3 = 0
# ƒOƒ‰ƒf[ƒVƒ‡ƒ“Ý’è grade1:‹óƒQ[ƒW grade2:ŽÀƒQ[ƒW
# (0:‰¡‚ɃOƒ‰ƒf[ƒVƒ‡ƒ“ 1:c‚ɃOƒ‰ƒf[ƒVƒ‡ƒ“ 2:ŽÎ‚߂ɃOƒ‰ƒf[ƒVƒ‡ƒ“(Œƒd)j
grade1 = 1
grade2 = 0
# FÝ’èBcolor1:ŠO˜gCcolor2:’†˜g
# color3:‹óƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor4:‹óƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
# color5:ŽÀƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor6:ŽÀƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 255, 192, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 64, 0, 192)
color5 = Color.new(14 * rate, 80 - 24 * rate, 80 * rate, 192)
color6 = Color.new(62 * rate, 240 - 72 * rate, 240 * rate, 192)
# •Ï”sp‚É•`‰æ‚·‚éƒQ[ƒW‚Ì•‚ð‘ã“ü
if actor.maxsp != 0
sp = (width + plus_width) * actor.sp * rate_width / 100 / actor.maxsp
else
sp = (width + plus_width) * rate_width / 100
end
# ƒQ[ƒW‚Ì•`‰æ
gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
width, plus_width + width * rate_width / 100,
height, sp, align1, align2, align3,
color1, color2, color3, color4, color5, color6, grade1, grade2)
# ƒIƒŠƒWƒiƒ‹‚ÌSP•`‰æˆ—‚ðŒÄ‚яo‚µ
draw_actor_sp_original(actor, x, y, width)
end
#----------------------------------
# œ EXP ƒQ[ƒW‚Ì•`‰æ
#----------------------------------
# ƒIƒŠƒWƒiƒ‹‚ÌEXP•`‰æ‚ð draw_actor_sp_original ‚Æ–Œ‘O•ÏX
alias :draw_actor_exp_original :draw_actor_exp
def draw_actor_exp(actor, x, y, width = 204)
# •Ï”rate‚É Œ»Ý‚Ìexp/nextexp‚ð‘ã“ü
if actor.next_exp != 0
rate = actor.now_exp.to_f / actor.next_exp
else
rate = 1
end
# 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 = 25
plus_width = 0
rate_width = 100
height = 10
align1 = 1
align2 = 2
align3 = 0
# ƒOƒ‰ƒf[ƒVƒ‡ƒ“Ý’è grade1:‹óƒQ[ƒW grade2:ŽÀƒQ[ƒW
# (0:‰¡‚ɃOƒ‰ƒf[ƒVƒ‡ƒ“ 1:c‚ɃOƒ‰ƒf[ƒVƒ‡ƒ“ 2:ŽÎ‚߂ɃOƒ‰ƒf[ƒVƒ‡ƒ“(Œƒd)j
grade1 = 1
grade2 = 0
# FÝ’èBcolor1:ŠO˜gCcolor2:’†˜g
# color3:‹óƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor4:‹óƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
# color5:ŽÀƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor6:ŽÀƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 255, 192, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(64, 0, 0, 192)
color5 = Color.new(80 * rate, 80 - 80 * rate ** 2, 80 - 80 * rate, 192)
color6 = Color.new(240 * rate, 240 - 240 * rate ** 2, 240 - 240 * rate, 192)
# •Ï”exp‚É•`‰æ‚·‚éƒQ[ƒW‚Ì•‚ð‘ã“ü
if actor.next_exp != 0
exp = (width + plus_width) * actor.now_exp * rate_width /
100 / actor.next_exp
else
exp = (width + plus_width) * rate_width / 100
end
# ƒQ[ƒW‚Ì•`‰æ
gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
width, plus_width + width * rate_width / 100,
height, exp, align1, align2, align3,
color1, color2, color3, color4, color5, color6, grade1, grade2)
# ƒIƒŠƒWƒiƒ‹‚ÌEXP•`‰æˆ—‚ðŒÄ‚яo‚µ
draw_actor_exp_original(actor, x, y)
end
#----------------------------------
# œ ƒQ[ƒW‚Ì•`‰æ
#----------------------------------
def gauge_rect(x, y, rect_width, width, height, gauge, align1, align2, align3,
color1, color2, color3, color4, color5, color6, grade1, grade2)
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
# ˜g•`‰æ
self.contents.fill_rect(x, y, width, height, color1)
self.contents.fill_rect(x + 1, y + 1, width - 2, height - 2, color2)
if align3 == 0
if grade1 == 2
grade1 = 3
end
if grade2 == 2
grade2 = 3
end
end
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
end
# ‹óƒQ[ƒW‚Ì•`‰æ
self.contents.gradation_rect(x + 2, y + 2, width - 4, height - 4,
color3, color4, grade1)
if align3 == 1
x += width - gauge
end
# ŽÀƒQ[ƒW‚Ì•`‰æ
self.contents.gradation_rect(x + 2, y + 2, gauge - 4, height - 4,
color5, color6, grade2)
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

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

module RPG
class Sprite < ::Sprite
def damage(value, critical)
dispose_damage
if value.is_a?(Numeric)
damage_string = value.abs.to_s
else
damage_string = value.to_s
end
bitmap = Bitmap.new(160, 48)
bitmap.font.name = "Arial Black"
bitmap.font.size = 32
bitmap.font.color.set(0, 0, 0)
bitmap.draw_text(-1, 12-1, 160, 36, damage_string, 1)
bitmap.draw_text(+1, 12-1, 160, 36, damage_string, 1)
bitmap.draw_text(-1, 12+1, 160, 36, damage_string, 1)
bitmap.draw_text(+1, 12+1, 160, 36, damage_string, 1)
if value.is_a?(Numeric) and value < 0
bitmap.font.color.set(176, 255, 144)
else
bitmap.font.color.set(255, 255, 255)
end
bitmap.draw_text(0, 12, 160, 36, damage_string, 1)
if critical
bitmap.font.size = 20
bitmap.font.color.set(0, 0, 0)
bitmap.draw_text(-1, -1, 160, 20, "CRITICAL", 1)
bitmap.draw_text(+1, -1, 160, 20, "CRITICAL", 1)
bitmap.draw_text(-1, +1, 160, 20, "CRITICAL", 1)
bitmap.draw_text(+1, +1, 160, 20, "CRITICAL", 1)
bitmap.font.color.set(255, 255, 255)
bitmap.draw_text(0, 0, 160, 20, "CRITICAL", 1)
end
@_damage_sprite = ::Sprite.new
@_damage_sprite.bitmap = bitmap
@_damage_sprite.ox = 80 + self.viewport.ox
@_damage_sprite.oy = 20 + self.viewport.oy
@_damage_sprite.x = self.x + self.viewport.rect.x
@_damage_sprite.y = self.y - self.oy / 2 + self.viewport.rect.y
@_damage_sprite.z = 3000
@_damage_duration = 40
end
def animation(animation, hit)
dispose_animation
@_animation = animation
return if @_animation == nil
@_animation_hit = hit
@_animation_duration = @_animation.frame_max
animation_name = @_animation.animation_name
animation_hue = @_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
@_animation_sprites = []
if @_animation.position != 3 or not @@_animations.include?(animation)
for i in 0..15
sprite = ::Sprite.new
sprite.bitmap = bitmap
sprite.visible = false
@_animation_sprites.push(sprite)
end
unless @@_animations.include?(animation)
@@_animations.push(animation)
end
end
update_animation
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 animation_set_sprites(sprites, cell_data, position)
for i in 0..15
sprite = sprites[i]
pattern = cell_data[i, 0]
if sprite == nil or pattern == nil or pattern == -1
sprite.visible = false if sprite != nil
next
end
sprite.visible = true
sprite.src_rect.set(pattern % 5 * 192, pattern / 5 * 192, 192, 192)
if position == 3
if self.viewport != nil
sprite.x = self.viewport.rect.width / 2
sprite.y = self.viewport.rect.height - 160
else
sprite.x = 320
sprite.y = 240
end
else
sprite.x = self.x + self.viewport.rect.x -
self.ox + self.src_rect.width / 2
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
sprite.x += cell_data[i, 1]
sprite.y += cell_data[i, 2]
sprite.z = 2000
sprite.ox = 96
sprite.oy = 96
sprite.zoom_x = cell_data[i, 3] / 100.0
sprite.zoom_y = cell_data[i, 3] / 100.0
sprite.angle = cell_data[i, 4]
sprite.mirror = (cell_data[i, 5] == 1)
sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
sprite.blend_type = cell_data[i, 7]
end
end
end
end



 

Et le deuxième, nommé le "Bob" (très long script) et copier coller.


Code:
# ƒŠƒ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
              
      


<--------------------------------->
nosferatus the-demon-of-the-world

Sam 12 Avr - 23:00 (2008) Visiter le site web du posteur Yahoo Messenger MSN
Publicité






Message Publicité
PublicitéSupprimer les publicités ?

Sam 12 Avr - 23:00 (2008)
Jiihn
Petit maker

Hors ligne

Inscrit le: 01 Avr 2008
Messages: 28
Localisation: 78
Masculin Capricorne (22déc-19jan) 猴 Singe

Message Combats relookée Répondre en citant
montre des screens pour voir ce que ça fait.


Dim 13 Avr - 11:03 (2008) MSN
nosferatus
Maker

Hors ligne

Inscrit le: 01 Avr 2008
Messages: 99
Localisation: france
Masculin Cancer (21juin-23juil) 狗 Chien

Message Combats relookée Répondre en citant
y a pas de screen mais au lieux de voir les personnage de face vous les voyer de cotés sa change la positons des combats

<--------------------------------->
nosferatus the-demon-of-the-world

Dim 13 Avr - 14:01 (2008) Visiter le site web du posteur Yahoo Messenger MSN
Contenu Sponsorisé






Message Combats relookée

Aujourd’hui à 14:37 (2018)
Montrer les messages depuis:    
Répondre au sujet    Le forum de la production "Warrior Games Production" Index du Forum » Vos Projets » Scripts Toutes les heures sont au format GMT + 2 Heures
Page 1 sur 1

 
Sauter vers: 

Index | Panneau d’administration | Creer un forum | Forum gratuit d’entraide | Annuaire des forums gratuits | Signaler une violation | Conditions générales d'utilisation
Powered by phpBB © 2001, 2005 phpBB Group
Design by Freestyle XL / Music Lyrics.Traduction par : phpBB-fr.com