[RPG-MAKER.FR] Oniromancie: tout l'univers de RPG Maker en français - Scripts

Auteur : Krazplay
Logiciel : RPG Maker XP
Nombre de scripts : 2

Fonctionnalités
Modifie le menu de base pour afficher les sprites des héros sur des losanges.

Installation
A placer au-dessus de Main.
Le script Window_MenuStatus est à remplacer par le deuxième script.

#--------------------------------- 
# Menu_CMS par Krazplay 
#--------------------------------- 
def draw_actor_battler(actor, x, y) 
bitmap = RPG::Cache.battler(actor.battler_name, actor.battler_hue) 
cw = bitmap.width 
ch = bitmap.height 
src_rect = Rect.new(0, 0, cw, ch) 
self.contents.blt(x - cw / 2, y - ch / 2, bitmap, src_rect) 
end 
 
 
#--------------------------------- 
#Def draw line 
#--------------------------------- 
def draw_line(start_x, start_y, end_x, end_y, start_color, width = 1, end_color = start_color) 
# ??????????????????? 
distance = (start_x - end_x).abs + (start_y - end_y).abs 
# ???? 
if end_color == start_color 
for i in 1..distance 
x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i 
y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i 
if width == 1 
self.set_pixel(x, y, start_color) 
else 
self.fill_rect(x, y, width, width, start_color) 
end 
end 
else 
for i in 1..distance 
x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i 
y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i 
r = start_color.red * (distance-i)/distance + end_color.red * i/distance 
g = start_color.green * (distance-i)/distance + end_color.green * i/distance 
b = start_color.blue * (distance-i)/distance + end_color.blue * i/distance 
a = start_color.alpha * (distance-i)/distance + end_color.alpha * i/distance 
if width == 1 
self.set_pixel(x, y, Color.new(r, g, b, a)) 
else 
self.fill_rect(x, y, width, width, Color.new(r, g, b, a)) 
end 
end 
end 
end 
 
 
#--------------------------------- 
#Def draw polygon (pour faire les contours des faces) 
#--------------------------------- 
def draw_polygon(peaks, color, width = 1) 
# ?(=??)?????????? 
for i in 0 ... (peaks.size - 1) 
# ????????? 
draw_line( peaks[i][0], peaks[i][1], peaks[i+1][0], peaks[i+1][1], color, width ) 
end 
# ?????????????? 
draw_line( peaks[peaks.size - 1][0], peaks[peaks.size - 1][1], peaks[0][0], peaks[0][1], color, width ) 
end 
 
 
#--------------------------------- 
#def draw face (les faces à proprement parler ^^) 
#--------------------------------- 
def draw_facesquare(character_name, character_hue, x, y, size = 24) 
bitmap = RPG::Cache.character(character_name, character_hue) 
src_rect = Rect.new((bitmap.width/4 - size)/2, 0, size, size) 
self.blt(x, y, bitmap, src_rect) 
self.draw_polygon([[x,y],[x+size,y],[x+size,y+size],[x,y+size]], Color.new(255,255,255,128)) 
end 
# HP/SP/EXPƒQ?[ƒW•\´¦ƒXƒNƒ¦ƒvƒg Ver 1.00 
# ”z•z¼³?EƒTƒ|?[ƒgURL 
# [url=http://members.jcom.home.ne.jp/cogwheel/]http://members.jcom.home.ne.jp/cogwheel/[/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‚½‚È‹@”\‚ð’Ç‰Á‚µ‚Ü‚•?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, 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 
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 
 
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

#============================================================================== 
# ■ Window_MenuStatus 
#------------------------------------------------------------------------------ 
# Menu spécial de Silversun 
#============================================================================== 
 
class Window_MenuStatus < Window_Selectable 
#-------------------------------------------------------------------------- 
# ● オブジェクト初期化 
#-------------------------------------------------------------------------- 
def initialize 
super(0, 0, 480, 480) 
self.contents = Bitmap.new(width - 32, height - 32) 
self.contents.font.name = $fontface 
self.contents.font.size = $fontsize 
refresh 
self.active = false 
self.index = -1 
end 
#-------------------------------------------------------------------------- 
# ● リフレッシュ 
#-------------------------------------------------------------------------- 
def refresh 
self.contents.clear 
@item_max = $game_party.actors.size 
for i in 0...$game_party.actors.size 
y = 270 
x = 220 
actor = $game_party.actors[i] 
actor1 = $game_party.actors[0] 
actor2 = $game_party.actors[1] 
actor3 = $game_party.actors[2] 
actor4 = $game_party.actors[3] 
self.contents.draw_facesquare(actor.character_name, actor.character_hue,10+32*i, 5 ) 
if @item_max >= 4 
#variables 
cnw = contents.text_size(actor4.name).width 
cnh = contents.text_size(actor4.name).height 
ccw = contents.text_size(actor4.class_name).width 
cch = contents.text_size(actor4.class_name).height 
chpw = contents.text_size(actor4.hp.to_s).width 
cspw = contents.text_size(actor4.sp.to_s).width 
#draw 
draw_actor_battler(actor4,x, y-100) 
draw_actor_name(actor4, x-cnw/2, y-275) 
draw_actor_class(actor4, x-ccw/2, y-275+cnh) 
draw_actor_level(actor4, x-130, y - 275+cnh+cch/2) 
draw_actor_state(actor4, x +80, y - 275+cnh+cch/2) 
draw_actor_hp(actor4, x-chpw*2, y - 275+cnh*2) 
draw_actor_sp(actor4, x -cspw*2, y - 275+cnh*3) 
end 
if @item_max >= 3 
#variables 
cnw = contents.text_size(actor3.name).width 
cnh = contents.text_size(actor3.name).height 
ccw = contents.text_size(actor3.class_name).width 
cch = contents.text_size(actor3.class_name).height 
clw = contents.text_size(actor3.level.to_s).width 
chpw = contents.text_size(actor3.hp.to_s).width 
cspw = contents.text_size(actor3.sp.to_s).width 
#draw 
draw_actor_battler(actor3, x+70, y - 70) 
draw_actor_name(actor3, x+180-cnw/2+10, y-140) 
draw_actor_class(actor3, x+180-cch/2-35, y-140+cnh) 
draw_actor_level(actor3, x+180-clw, y -140+cnh+cch) 
draw_actor_state(actor3, x+180-35, y -140+cnh*3) 
draw_actor_hp(actor3, x+180-100, y-140+cnh*4) 
draw_actor_sp(actor3, x+180-100, y-140+cnh*5) 
end 
if @item_max >= 2 
#variables 
cnw = contents.text_size(actor2.name).width 
cnh = contents.text_size(actor2.name).height 
ccw = contents.text_size(actor2.class_name).width 
cch = contents.text_size(actor2.class_name).height 
#draw 
draw_actor_battler(actor2, x-70,y-70) 
draw_actor_name(actor2, x-220, y-140) 
draw_actor_class(actor2, x-220, y-140+cnh) 
draw_actor_level(actor2, x-220, y -140+cnh+cch) 
draw_actor_state(actor2, x-220, y -140+cnh*3) 
draw_actor_hp(actor2, x-220, y-140+cnh*4) 
draw_actor_sp(actor2, x-220, y-140+cnh*5) 
end 
if @item_max >= 1 
#variables 
cnw = contents.text_size(actor1.name).width 
cnh = contents.text_size(actor1.name).height 
ccw = contents.text_size(actor1.class_name).width 
cch = contents.text_size(actor1.class_name).height 
chpw = contents.text_size(actor1.hp.to_s).width 
cspw = contents.text_size(actor1.sp.to_s).width 
#draw 
draw_actor_battler(actor1, x,y) 
draw_actor_name(actor1, x-cnw/2, y+80) 
draw_actor_class(actor1, x-ccw/2, y+80+cnh) 
draw_actor_level(actor1, x-130, y + 80+cnh+cch/2) 
draw_actor_state(actor1, x +80, y + 80+cnh+cch/2) 
draw_actor_hp(actor1, x-chpw*2, y + 80+cnh*2) 
draw_actor_sp(actor1, x -cspw*2, y + 80+cnh*3) 
end 
 
end 
end 
#-------------------------------------------------------------------------- 
# ● カーソルの矩形更新 
#-------------------------------------------------------------------------- 
def update_cursor_rect 
if @index < 0 
self.cursor_rect.empty 
else 
self.cursor_rect.set(7+@index*32, 2, 31, 31) 
end 
end 
end