Menu horizontal
Aug 15, 2014 13:03:32 GMT -4
Post por Night Shade en Aug 15, 2014 13:03:32 GMT -4
Autor: Kyo panda
Versión: 1.0
Explicación:
Pues no hay mucho que decir, solo que es un magnifico menú en forma horizontal y no ocupa ningún tipo de imágenes en especial.
Imágenes:
Script:
Instrucciones:
Pegar encima del main y configurar a su gus
Versión: 1.0
Explicación:
Pues no hay mucho que decir, solo que es un magnifico menú en forma horizontal y no ocupa ningún tipo de imágenes en especial.
Imágenes:
Script:
#==============================================================================
# Menu Horizontal [XP]
#------------------------------------------------------------------------------
# Modifica o menu padrão do RPG Maker XP e adiciona algumas novas janelas.
#------------------------------------------------------------------------------
# Autor: Kyo Panda (http://www.mundorpgmaker.com/)
# Atualização: 08/03/2010
# Versão: 1.0
#==============================================================================
module PANDA_MH
#--------------------------------------------------------------------------
# Configuração
#--------------------------------------------------------------------------
# Defina aqui quais menus do Menu Horizontal serão utilizados ou não.
# Defina true para sim e false para não.
HORIZONTAL_MENU_MAIN = true # Menu Principal
HORIZONTAL_MENU_STATUS = true # Menu de Status
# Defina aqui quais janelas você deseja que estajam visíveis ou não no Menu
# Principal.
# Defina true para visível e false para invisível.
MAPNAME_ACTIVE = true # Nome do mapa
GOLD_ACTIVE = true # Dinheiro STEPS_ACTIVE = true # Passos
TIME_ACTIVE = true # Tempo de jogo
# Defina aqui os backgrounds dos menus.
# O arquivo deve estar contido na pasta "Graphics/Panoramas".
# O nome do arquivo deve estar entre aspas ("") ou apóstrofes ('').
# Defina como "" ou '' para não utilizar
MENU_BACK = "004-CloudySky01" # Menu Principal
STATUS_BACK = "003-StarlitSky01" # Menu de Status
# Defina aqui o nome da fonte utilizada nos menus.
# A fonte será lida por ordem de index na array, se a primeira fonte não
# existir ele procurará a segunda e assim em diante.
MENU_FONT = ["Calibri", "Arial", "Verdana"] # Fonte do Menu Principal
MENU_FONT_SIZE = 22 # Tamanho da fonte do Menu Principal
STATUS_FONT = ["Calibri", "Arial", "Verdana"] # Fonte do Menu de Status
STATUS_FONT_SIZE = 22 # Tamanho da fonte do Menu de Status
# Defina aqui os ícones utilizados no Menu Principal, por index do ícone.
# O arquivo deve estar contido na pasta "Graphics/Icons".
# O nome do arquivo deve estar entre aspas ("") ou apóstrofes ('').
ITENS_ICON = "032-Item01" # Itens
SKILL_ICON = "044-Skill01" # Habilidades
EQUIP_ICON = "013-Body01" # Equipamento
STATUS_ICON = "045-Skill02" # Status
SAVE_ICON = "040-Item09" # Salvar
EXIT_ICON = "047-Skill04" # Sair
MAPNAME_ICON = "038-Item07" # Nome do mapa
GOLD_ICON = "035-Item04" # Dinheiro
STEPS_ICON = "020-Accessory05" # Passos
TIME_ICON = "039-Item08" # Tempo de jogo
# Defina aqui a opacidade dos menus. (0 = Translúcido, 255 = Opaco)
MENU_OPACITY = 200 # Menu Principal
STATUS_OPACITY = 200 # Menu de Status
# Defina aqui o número de itens existente no menu de comando, para scroll.
# Para scripters, não mude o valor se deseja apenas as seis opções padrões.
ITEM_NUMBER = 6
#--------------------------------------------------------------------------
# Fim da configuração
#--------------------------------------------------------------------------
end
#==============================================================================
# Game_Temp
#------------------------------------------------------------------------------
# Esta classe controla dados que não são salvos pelo jogo, os dados temporários
# Pode ser acessada utilizando $game_temp
#==============================================================================
class Game_Temp
#--------------------------------------------------------------------------
# Variáveis públicas
#--------------------------------------------------------------------------
attr_accessor :background_bitmap # Bitmap de fundo
#--------------------------------------------------------------------------
# Alias da inicialização do objeto
#--------------------------------------------------------------------------
alias horizontal_menu_initialize initialize
#--------------------------------------------------------------------------
# Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
# Roda o método original
horizontal_menu_initialize
@background_bitmap = Bitmap.new(1, 1)
end
end
#==============================================================================
# Scene_Base
#------------------------------------------------------------------------------
# Classe superior à todas as classes Scene_.
#==============================================================================
class Scene_Base
#--------------------------------------------------------------------------
# Processo principal
#--------------------------------------------------------------------------
def main
start # Inicia o processo
perform_transition # Executa a transição
post_start # Processo pós-inicialização
Input.update # Atualiza as informações inseridas
loop do
Graphics.update # Atualiza os gráficos
Input.update # Atualiza as informações inseridas
update # Atualização
break if $scene != self # Descontinuação do loop
end
Graphics.update
pre_terminate # Preparação para finalização
Graphics.freeze # Congelamento dos gráficos
terminate # Fim
end
#--------------------------------------------------------------------------
# Inicialização do processo
#--------------------------------------------------------------------------
def start
end
#--------------------------------------------------------------------------
# Execução da transição
#--------------------------------------------------------------------------
def perform_transition
Graphics.transition(10)
end
#--------------------------------------------------------------------------
# Processo pós-inicialização
#--------------------------------------------------------------------------
def post_start
end
#--------------------------------------------------------------------------
# Atualização da tela
#--------------------------------------------------------------------------
def update
end
#--------------------------------------------------------------------------
# Preparação para finalização
#--------------------------------------------------------------------------
def pre_terminate
end
#--------------------------------------------------------------------------
# Fim do processo
#--------------------------------------------------------------------------
def terminate
end
#--------------------------------------------------------------------------
# Preparação do background para uma tela diferente
#--------------------------------------------------------------------------
def snapshot_for_background
$game_temp.background_bitmap.dispose
$game_temp.background_bitmap = Graphics.snap_to_bitmap
$game_temp.background_bitmap.blur
end
#--------------------------------------------------------------------------
# Criação do background do menu
#--------------------------------------------------------------------------
def create_menu_background
@menuback_sprite = Sprite.new
@menuback_sprite.bitmap = $game_temp.background_bitmap
@menuback_sprite.color.set(16, 16, 16, 128)
update_menu_background
end
#--------------------------------------------------------------------------
# Dispose do background do menu
#--------------------------------------------------------------------------
def dispose_menu_background
@menuback_sprite.dispose
end
#--------------------------------------------------------------------------
# Atualização do background do menu
#--------------------------------------------------------------------------
def update_menu_background
end
end
#==============================================================================
# Vocab
#------------------------------------------------------------------------------
# Esta classe controla o vocabulário e mensagens do jogo. Algumas mensagens
# são adquiridas utilizando a variável global $data_system.
#==============================================================================
module Vocab
# Nível
def self.level
return "Nível"
end
# Nível (abreviado)
def self.level_a
return "N"
end
# HP (abreviado)
def self.hp_a
return "H"
end
# MP (abreviado)
def self.mp_a
return "M"
end
# Equipamento
def self.equip
return "Equipamento"
end
# Frases de status
ExpTotal = "Experiência Total"
ExpNext = "Próximo %s"
# Taxa de acerto
def self.hit
return "Acerto %"
end
# Taxa de evasão
def self.eva
return "Evasão %"
end
# Taxa de acerto
def self.cri
return "Crítico %"
end
# Taxa de sorte
def self.odds
return "Sorte %"
end
end
#==============================================================================
# Window_HorizontalSelectable
#------------------------------------------------------------------------------
# Classe que tem a função de gerenciar os movimentos do cursor nas janelas
# de seleção no sentido horizontal.
#------------------------------------------------------------------------------
# Autor: Kyo Panda (http://www.mundorpgmaker.com/)
# Lançado em: 25/01/2010
# Versão: 1.0
#==============================================================================
class Window_HorizontalSelectable < Window_Base
#--------------------------------------------------------------------------
# Variáveis públicas
#--------------------------------------------------------------------------
attr_reader :item_max # Máximo de items
attr_reader :row_max # Máximo de linhas
attr_reader :index # Posição do cursor
attr_reader :help_window # Janela de ajuda
#--------------------------------------------------------------------------
# Inicialização do objeto
# x : coordenada X da janela
# y : coordenada Y da janela
# width : largura da janela
# height : altura da janela
# spacing : espaçamento entre items localizados próximos
#--------------------------------------------------------------------------
def initialize(x, y, width, height, spacing = 32)
@item_max = 1
@row_max = 1
@index = -1
@spacing = spacing
super(x, y, width, height)
end
#--------------------------------------------------------------------------
# Criação do conteúdo da janela
#--------------------------------------------------------------------------
def create_contents
self.contents.dispose
self.contents = Bitmap.new([width - 32, column_max * 32].max, height - 32)
end
#--------------------------------------------------------------------------
# Posicionamento do cursor
# index : o novo cursor
#--------------------------------------------------------------------------
def index=(index)
@index = index
update_cursor
call_update_help
end
#--------------------------------------------------------------------------
# Número de colunas
#--------------------------------------------------------------------------
def column_max
return (@item_max + @row_max - 1) / @row_max
end
#--------------------------------------------------------------------------
# Resgate da informação da primeira coluna
#--------------------------------------------------------------------------
def top_column
return self.ox / 24
end
#--------------------------------------------------------------------------
# Configuração da primeira coluna
# column : exibição da primeira coluna
#--------------------------------------------------------------------------
def top_column=(column)
column = 0 if column < 0
column = column_max - 1 if column > column_max - 1
self.ox = column * 24
end
#--------------------------------------------------------------------------
# Máximo de colunas em uma página
#--------------------------------------------------------------------------
def page_column_max
return (self.width - 32) / 24
end
#--------------------------------------------------------------------------
# Máximo de itens em uma página
#--------------------------------------------------------------------------
def page_item_max
return page_column_max * @row_max
end
#--------------------------------------------------------------------------
# Resgate da informação da última coluna
#--------------------------------------------------------------------------
def bottom_column
return top_column + page_column_max - 1
end
#--------------------------------------------------------------------------
# Configuração da última coluna
# column : exibição da última coluna
#--------------------------------------------------------------------------
def bottom_column=(column)
self.top_column = column - (page_column_max - 1)
end
#--------------------------------------------------------------------------
# Configuração do retângulo onde o item é desenhado
# index : número de itens
#--------------------------------------------------------------------------
def item_rect(index)
rect = Rect.new(0, 0, 0, 0)
rect.width = 24
rect.height = (contents.height + @spacing) / @row_max - @spacing
rect.x = index / @row_max * 24
rect.y = index % @row_max * (rect.height + @spacing)
return rect
end
#--------------------------------------------------------------------------
# Configurações da janela de ajuda
# help_window : nova janela de ajuda
#--------------------------------------------------------------------------
def help_window=(help_window)
@help_window = help_window
call_update_help
end
#--------------------------------------------------------------------------
# Verificação da possibilidade de movimento do cursor
#--------------------------------------------------------------------------
def cursor_movable?
return false if (not visible or not active)
return false if (index < 0 or index > @item_max or @item_max == 0)
return false if (@opening or @closing)
return true
end
#--------------------------------------------------------------------------
# Mover cursor para direita
# wrap : permissão de wrap
#--------------------------------------------------------------------------
def cursor_right(wrap = false)
if (@index < @item_max - @row_max) or (wrap and @row_max == 1)
@index = (@index + @row_max) % @item_max
end
end
#--------------------------------------------------------------------------
# Mover cursor para esquerda
# wrap : permissão de wrap
#--------------------------------------------------------------------------
def cursor_left(wrap = false)
if (@index >= @row_max) or (wrap and @row_max == 1)
@index = (@index - @row_max + @item_max) % @item_max
end
end
#--------------------------------------------------------------------------
# Mover cursor para cima
# wrap : permissão de wrap
#--------------------------------------------------------------------------
def cursor_up(wrap = false)
if (@row_max >= 2) and
(@index < @item_max - 1 or (wrap and page_column_max == 1))
@index = (@index + 1) % @item_max
end
end
#--------------------------------------------------------------------------
# Mover cursor para baixo
# wrap : permissão de wrap
#--------------------------------------------------------------------------
def cursor_down(wrap = false)
if (@row_max >= 2) and
(@index > 0 or (wrap and page_column_max == 1))
@index = (@index - 1 + @item_max) % @item_max
end
end
#--------------------------------------------------------------------------
# Volta uma página com o cursor
#--------------------------------------------------------------------------
def cursor_pagedown
if top_column + page_column_max < column_max
@index = [@index + page_item_max, @item_max - 1].min
self.top_column += page_column_max
end
end
#--------------------------------------------------------------------------
# Avança uma página com o cursor
#--------------------------------------------------------------------------
def cursor_pageup
if top_column > 0
@index = [@index - page_item_max, 0].max
self.top_column -= page_column_max
end
end
#--------------------------------------------------------------------------
# Atualização da tela
#--------------------------------------------------------------------------
def update
super
if cursor_movable?
last_index = @index
if Input.repeat?(Input::DOWN)
cursor_down(Input.trigger?(Input::DOWN))
end
if Input.repeat?(Input::UP)
cursor_up(Input.trigger?(Input::UP))
end
if Input.repeat?(Input::RIGHT)
cursor_right(Input.trigger?(Input::RIGHT))
end
if Input.repeat?(Input::LEFT)
cursor_left(Input.trigger?(Input::LEFT))
end
if Input.repeat?(Input::R)
cursor_pagedown
end
if Input.repeat?(Input::L)
cursor_pageup
end
if @index != last_index
$game_system.se_play($data_system.cursor_se)
end
end
update_cursor
call_update_help
end
#--------------------------------------------------------------------------
# Atualização do cursor
#--------------------------------------------------------------------------
def update_cursor
if @index < 0 # Se o cursor for menor que 0
self.cursor_rect.empty # Desabilita o cursor
else # Ou se o cursor for maior que 0
column = @index / @row_max # Pegue a coluna atual
if column < top_column # Aparece na primeira coluna
self.top_column = column # A coluna atual se torna uma "scroll"
end
if column > bottom_column # É exibida a partir do final
self.bottom_column = column # A coluna atual se torna uma "scroll"
end
rect = item_rect(@index) # Escolhe items que o retângulo pega
rect.x -= self.ox # Scroll da posição retangular
self.cursor_rect = rect # Atualização do cursor retangular
end
end
#--------------------------------------------------------------------------
# Atualização da janela de ajuda
#--------------------------------------------------------------------------
def call_update_help
if self.active and @help_window != nil
update_help
end
end
#--------------------------------------------------------------------------
# Atualização da janela de ajuda (quando hereditariedade está definida)
#--------------------------------------------------------------------------
def update_help
end
end
#==============================================================================
# Ellipse
#------------------------------------------------------------------------------
# Armazena um objeto elíptico.
#==============================================================================
class Ellipse
#--------------------------------------------------------------------------
# Variáveis públicas
#--------------------------------------------------------------------------
attr_reader :a # A largura do círculo
attr_reader :b # A altura do círculo
attr_reader :x # O posicionamento horizontal
attr_reader :y # O posicionamento vertical
attr_reader :h # O posicionamento horizontal em sua origem
attr_reader :k # O posicionamento vertical em sua origem
#--------------------------------------------------------------------------
# Inicialização do objeto
# x : o posicionamento horizontal
# y : o posicionamento vertical
# a : a largura do círculo em sua origem do seu lado
# b : a altura do círculo em sua origem. Se nil, é o radius do círculo
#--------------------------------------------------------------------------
def initialize (x, y, a, b = nil)
@x = x
@y = y
@a = a
@b = b.nil? ? a : b
@h = x + a
@k = y + @b
end
#--------------------------------------------------------------------------
# Em conjunto?
# x : a coordenada horizontal sendo testada
# y : a coordenada vertical sendo testada
#--------------------------------------------------------------------------
def within? (x, y)
x_square = ((x - @h)*(x - @h)).to_f / (@a*@a)
y_square = ((y - @k)*(y - @k)).to_f / (@b*@b)
# Se "radius" <= 1, então isso deve estar em conjunto com a ellipse
return (x_square + y_square) <= 1
end
end
#==============================================================================
# Bitmap
#------------------------------------------------------------------------------
# Classe que comanda toda e qualquer imagem exibida no jogo.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Novos métodos: outiline_ellipse, fill_ellipse e fill_rounded_rect.
#==============================================================================
class Bitmap
#--------------------------------------------------------------------------
# Contorno da elipse
# ellipse : a elipse sendo desenhada
# width : a largura da barra
# colour : a cor do contorno
#--------------------------------------------------------------------------
def outline_ellipse (ellipse, colour = font.color, width = 1, steps = 0)
# Para organização, define as variáveis locais a e b para as variáveis de elipse
a, b = ellipse.a, ellipse.b
# Usa a aproximação de Ramanujan para a circunferência da elipse
steps = Math::PI*(3*(a + b) - Math.sqrt((3*a + b)*(a + 3*b))) if steps == 0
radian_modifier = (2*Math::PI) / steps
for i in 0...steps
t = (radian_modifier*i) % (2*Math::PI)
# Expressada parametricamente:
# x = h + acos(t), y = k + bsin(t) : onde t vai de 0 a 2pi
x = (ellipse.h + (a*Math.cos(t)))
y = (ellipse.k + (b*Math.sin(t)))
set_pixel (x, y, colour)
end
# Reforça a linha
if width > 1
ellipse = Ellipse.new (ellipse.x + 1, ellipse.y + 1, ellipse.a - 1, ellipse.b - 1)
outline_ellipse (ellipse, colour, width - 1, steps)
end
end
#--------------------------------------------------------------------------
# Preenche a elipse
# ellipse : a elipse sendo desenhada
# colour : a cor do contorno
#--------------------------------------------------------------------------
def fill_ellipse (ellipse, colour = font.color, steps = 0)
# Para organização, define as variáveis locais a e b para as variáveis de elipse
a, b = ellipse.a, ellipse.b
# Usa a aproximação de Ramanujan para a circunferência da elipse
steps = Math::PI*(3*(a + b) - Math.sqrt((3*a + b)*(a + 3*b))) if steps == 0
radian_modifier = (2*Math::PI) / steps
for i in 0...(steps / 2)
t = (radian_modifier*i) % (2*Math::PI)
# Expressada parametricamente:
# x = h + acos(t), y = k + bsin(t) : onde t vai de 0 a 2pi
x = ellipse.h + (a*Math.cos(t))
y = ellipse.k - (b*Math.sin(t))
fill_rect (x, y, 1, 2*(ellipse.k - y), colour)
end
end
#--------------------------------------------------------------------------
# Preenche retângulo circular
# rect : o retângulo sendo desenhado
# colour : a cor do contorno
# w : o número de pixels para cobrir o círculo
#--------------------------------------------------------------------------
# Usado para preencher retângulos com cantos circulares
#--------------------------------------------------------------------------
def fill_rounded_rect (rect, colour = font.color, w = 8)
# Desenha o corpo do retângulo
fill_rect (rect.x + w, rect.y, rect.width - 2*w, rect.height, colour)
# Desenha o retângulo horizontal
fill_rect (rect.x, rect.y + w, w, rect.height - 2*w, colour)
# Desenha o retângulo vertical
x = rect.x + rect.width - w
fill_rect (x, rect.y + w, w, rect.height - 2*w, colour)
# Faz um círculo
circle = Ellipse.new (0, 0, w)
for i in 0...w
for j in 0...w
# Canto superior esquerdo
set_pixel (rect.x + i, rect.y + j, colour) if circle.within? (i, j)
# Canto superior direito
set_pixel (rect.x + rect.width - w + i, rect.y + j, colour) if circle.within? (i + w, j)
# Canto inferior esquerdo
set_pixel (rect.x + i, rect.y + rect.height - w + j, colour) if circle.within? (i, j + w)
# Canto inferior direito
set_pixel (rect.x + rect.width - w + i, rect.y + rect.height - w + j, colour) if circle.within? (i + w, j + w)
end
end
end
end
#==============================================================================
# Game_Map
#------------------------------------------------------------------------------
# Esta classe controla o mapa do jogo. Funções como passagem, scroll e loop
# são definidas aqui. Pode ser acessada utilizando $game_map.
#==============================================================================
class Game_Map
#--------------------------------------------------------------------------
# Converte e carrega o nome do mapa
#--------------------------------------------------------------------------
def map_name
map_name = load_data("Data/MapInfos.rxdata")
return map_name[@map_id].name
end
end
#==============================================================================
# Game_Actor
#------------------------------------------------------------------------------
# Esta classe controla os personagens do jogo. Ela é utilizada dentro das
# classes Game_Actors ($game_actors) e Game_Party ($game_party).
#==============================================================================
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# Pontos de EXP restando para o próximo nível
#--------------------------------------------------------------------------
def next_rest_exp
return @exp_list[@level + 1] > 0 ? (@exp_list[@level + 1] - @exp) : 0
end
#--------------------------------------------------------------------------
# Pontos de EXP restando para o próximo nível da EXP máxima
#--------------------------------------------------------------------------
def next_max_exp
return @exp_list[@level + 1] - @exp_list[@level]
end
end
#==============================================================================
# Window_Base
#------------------------------------------------------------------------------
# Esta é a classe superior à todas as classes de janelas do jogo.
#==============================================================================
class Window_Base < Window
#--------------------------------------------------------------------------
# Configuração da cor do HP
# actor : herói
#--------------------------------------------------------------------------
def hp_color(actor)
return knockout_color if actor.hp == 0
return crisis_color if actor.hp < actor.maxhp / 4
return normal_color
end
#--------------------------------------------------------------------------
# Configuração da cor do MP
# actor : herói
#--------------------------------------------------------------------------
def mp_color(actor)
return crisis_color if actor.sp < actor.maxsp / 4
return normal_color
end
#--------------------------------------------------------------------------
# Exibição da EXP
# actor : herói
# x : exibe na coordenada X
# y : exibe na coordenada Y
# width : largura
#--------------------------------------------------------------------------
def draw_actor_exp_menu(actor, x, y, width = 120)
draw_actor_exp_gauge_menu(actor, x, y, width)
xr = x + width - 80
self.contents.font.color = system_color
if actor.next_max_exp > 0
self.contents.draw_text(x, y, 40, 24, Vocab::level_a)
self.contents.font.color = normal_color
self.contents.draw_text(xr, y, 80, 24, actor.level.to_s, 2)
end
end
#--------------------------------------------------------------------------
# Exibição do medidor da EXP
# actor : herói
# x : exibe na coordenada X
# y : exibe na coordenada Y
# width : largura
#--------------------------------------------------------------------------
def draw_actor_exp_gauge_menu(actor, x, y, width = 120)
max = actor.next_max_exp
gw = width * (max - actor.next_rest_exp) / max
self.contents.fill_rect(x, y + 24 - 8, width, 6, Color.new(32, 32, 64, 255))
self.contents.fill_rect(x, y + 24 - 8, gw, 6, Color.new(192, 128, 255, 255))
end
#--------------------------------------------------------------------------
# Exibição do HP
# actor : herói
# x : exibe na coordenada X
# y : exibe na coordenada Y
# width : largura
#--------------------------------------------------------------------------
def draw_actor_hp_menu(actor, x, y, width = 120)
draw_actor_hp_gauge_menu(actor, x, y, width)
self.contents.font.color = system_color
self.contents.draw_text(x, y, 30, 24, Vocab::hp_a)
self.contents.font.color = hp_color(actor)
xr = x + width
if width < 120
self.contents.draw_text(xr - 40, y, 40, 24, actor.hp.to_s, 2)
else
self.contents.draw_text(xr - 90, y, 40, 24, actor.hp.to_s, 2)
self.contents.font.color = normal_color
self.contents.draw_text(xr - 50, y, 10, 24, "/", 2)
self.contents.draw_text(xr - 40, y, 40, 24, actor.maxhp.to_s, 2)
end
end
#--------------------------------------------------------------------------
# Exibição do medidor de HP
# actor : herói
# x : exibe na coordenada X
# y : exibe na coordenada Y
# width : largura
#--------------------------------------------------------------------------
def draw_actor_hp_gauge_menu(actor, x, y, width = 120)
gw = width * actor.hp / actor.maxhp
self.contents.fill_rect(x, y + 24 - 8, width, 6, Color.new(32, 32, 64, 255))
self.contents.fill_rect(x, y + 24 - 8, gw, 6, Color.new(240, 192, 64, 255))
end
#--------------------------------------------------------------------------
# Exibição do MP
# actor : herói
# x : exibe na coordenada X
# y : exibe na coordenada Y
# width : largura
#--------------------------------------------------------------------------
def draw_actor_mp_menu(actor, x, y, width = 120)
draw_actor_mp_gauge_menu(actor, x, y, width)
self.contents.font.color = system_color
self.contents.draw_text(x, y, 30, 24, Vocab::mp_a)
self.contents.font.color = mp_color(actor)
xr = x + width
if width < 120
self.contents.draw_text(xr - 40, y, 40, 24, actor.sp.to_s, 2)
else
self.contents.draw_text(xr - 90, y, 40, 24, actor.sp.to_s, 2)
self.contents.font.color = normal_color
self.contents.draw_text(xr - 50, y, 10, 24, "/", 2)
self.contents.draw_text(xr - 40, y, 40, 24, actor.maxsp.to_s, 2)
end
end
#--------------------------------------------------------------------------
# Exibição do medidor de MP
# actor : herói
# x : exibe na coordenada X
# y : exibe na coordenada Y
# width : largura
#--------------------------------------------------------------------------
def draw_actor_mp_gauge_menu(actor, x, y, width = 120)
gw = width * actor.sp / [actor.maxsp, 1].max
self.contents.fill_rect(x, y + 24 - 8, width, 6, Color.new(32, 32, 64, 255))
self.contents.fill_rect(x, y + 24 - 8, gw, 6, Color.new(64, 192, 240, 255))
end
#--------------------------------------------------------------------------
# Exibição da unidade monetária com valor em posse
# value : valor em posse
# x : exibe na coordenada X
# y : exibe na coordenada Y
# width : largura
#--------------------------------------------------------------------------
def draw_currency_value(value, x, y, width)
cx = contents.text_size($data_system.words.gold).width
self.contents.font.color = normal_color
self.contents.draw_text(x, y, width-cx-2, 24, value.to_s, 2)
self.contents.font.color = system_color
self.contents.draw_text(x, y, width, 24, $data_system.words.gold, 2)
end
#--------------------------------------------------------------------------
# Exibição do número de passos dados
# value : passos
# x : exibe na coordenada X
# y : exibe na coordenada Y
# width : largura
#--------------------------------------------------------------------------
def draw_currency_steps_value(value, x, y, width)
self.contents.draw_text(x, y, width - 2, 24, value.to_s, 2)
end
#--------------------------------------------------------------------------
# Exibição dos parâmetros
# actor : herói
# x : exibe na coordenada X
# y : exibe na coordenada Y
# type : tipo do valor (0～3)
#--------------------------------------------------------------------------
def draw_actor_parameter_menu(actor, x, y, type)
case type
when 0
parameter_name = $data_system.words.atk
parameter_value = actor.atk
when 1
parameter_name = $data_system.words.pdef
parameter_value = actor.pdef
when 2
parameter_name = $data_system.words.mdef
parameter_value = actor.mdef
when 3
parameter_name = $data_system.words.str
parameter_value = actor.str
when 4
parameter_name = $data_system.words.dex
parameter_value = actor.dex
when 5
parameter_name = $data_system.words.agi
parameter_value = actor.agi
when 6
parameter_name = $data_system.words.int
parameter_value = actor.int
when 7
parameter_name = Vocab.hit
parameter_value = actor.hit
when 8
parameter_name = Vocab.eva
parameter_value = actor.eva
end
self.contents.font.color = system_color
self.contents.draw_text(x, y, 120, 32, parameter_name)
self.contents.font.color = normal_color
self.contents.draw_text(x + 120, y, 36, 32, parameter_value.to_s, 2)
end
end
#--------------------------------------------------------------------------
# Definição da utiização do Menu Horizontal
#--------------------------------------------------------------------------
unless PANDA_MH::HORIZONTAL_MENU_MAIN != true
#==============================================================================
# Window_MenuCommand
#------------------------------------------------------------------------------
# Janela de comandos do menu.
#==============================================================================
class Window_MenuCommand < Window_HorizontalSelectable
#--------------------------------------------------------------------------
# Inclusão das constantes do módulo PANDA_MH
#--------------------------------------------------------------------------
include PANDA_MH
#--------------------------------------------------------------------------
# Inicialização do objeto
# x : coordenada X da janela
# y : coordenada Y da janela
#--------------------------------------------------------------------------
def initialize(x, y)
@selection_rect = false
@selection_x = 0
super(x, y, 320, 24 + 32)
self.active = true
self.back_opacity = MENU_OPACITY
self.index = 0
# Define @iw (icon width: largura do ícone) para organização
@iw = (320 / 6) - (32 / 6)
width = 320
extra_width = (@iw * (ITEM_NUMBER - 6))
if ITEM_NUMBER > 0
width += extra_width
end
self.contents = Bitmap.new(width - 32, height - 32)
self.width = 320
refresh
end
#--------------------------------------------------------------------------
# Atualização
#--------------------------------------------------------------------------
def refresh
if @selection_rect
color = Color.new(0, 0, 0, 160)
self.contents.fill_rect(@selection_x, 0, @iw, 24, color)
end
@data = []
@data.push(0)
@data.push(1)
@data.push(2)
@data.push(3)
@data.push(4)
@data.push(5) self.contents.clear
@item_max = @data.size
for i in 0 .. @item_max
draw_item(i)
end
end
#--------------------------------------------------------------------------
# Desenho do item
# index : número (ID) do item
#--------------------------------------------------------------------------
def draw_item(index, enabled = true)
# Define @iw (icon width: largura do ícone) para organização
@iw = (320 / 6) - (32 / 6)
case index
when 0 # Itens
if $game_party.actors.size == 0
icon = RPG::Cache.icon(ITENS_ICON)
rect = Rect.new(0, 0, icon.width, icon.height)
self.contents.blt(12, 0, icon, rect, 128)
else
icon = RPG::Cache.icon(ITENS_ICON)
rect = Rect.new(0, 0, icon.width, icon.height)
self.contents.blt(12, 0, icon, rect)
end
when 1 # Habilidades
if $game_party.actors.size == 0
icon = RPG::Cache.icon(SKILL_ICON)
rect = Rect.new(0, 0, icon.width, icon.height)
self.contents.blt((@iw) + 12, 0, icon, rect, 128)
else
icon = RPG::Cache.icon(SKILL_ICON)
rect = Rect.new(0, 0, icon.width, icon.height)
self.contents.blt((@iw) + 12, 0, icon, rect)
end
when 2 # Equipamento
if $game_party.actors.size == 0
icon = RPG::Cache.icon(EQUIP_ICON)
rect = Rect.new(0, 0, icon.width, icon.height)
self.contents.blt((2 * @iw) + 12, 0, icon, rect, 128)
else
icon = RPG::Cache.icon(EQUIP_ICON)
rect = Rect.new(0, 0, icon.width, icon.height)
self.contents.blt((2 * @iw) + 12, 0, icon, rect)
end
when 3 # Status
if $game_party.actors.size == 0
icon = RPG::Cache.icon(STATUS_ICON)
rect = Rect.new(0, 0, icon.width, icon.height)
self.contents.blt((3 * @iw) + 12, 0, icon, rect, 128)
else
icon = RPG::Cache.icon(STATUS_ICON)
rect = Rect.new(0, 0, icon.width, icon.height)
self.contents.blt((3 * @iw) + 12, 0, icon, rect)
end
when 4 # Salvar
if $game_system.save_disabled
icon = RPG::Cache.icon(SAVE_ICON)
rect = Rect.new(0, 0, icon.width, icon.height)
self.contents.blt((4 * @iw) + 12, 0, icon, rect, 128)
else
icon = RPG::Cache.icon(SAVE_ICON)
rect = Rect.new(0, 0, icon.width, icon.height)
self.contents.blt((4 * @iw) + 12, 0, icon, rect)
end
when 5 # Sair
icon = RPG::Cache.icon(EXIT_ICON)
rect = Rect.new(0, 0, icon.width, icon.height)
self.contents.blt((5 * @iw) + 12, 0, icon, rect)
end
end
#--------------------------------------------------------------------------
# Definição do retângulo de seleção
#--------------------------------------------------------------------------
def set_selection_rect(index)
@selection_rect = true
@selection_x = index * @iw
refresh
end
#--------------------------------------------------------------------------
# Limpar retângulo de seleção
#--------------------------------------------------------------------------
def clear_selection_rect
@selection_rect = false
refresh
end
#--------------------------------------------------------------------------
# Atualização do cursor
#--------------------------------------------------------------------------
def update_cursor
if @index < 0 # Sem cursor
self.cursor_rect.empty
return
end
# Adquirir primeira coluna
column = @index / @row_max
if column < self.top_column
self.top_column = column
end
# Reiniciar para a primeira coluna se no fim da lista
if column > self.top_column + (self.page_column_max - 1)
self.top_column = column - (self.page_column_max - 1)
end
x = @index / @row_max * @iw - self.ox
# Definição do cursor
self.cursor_rect.set(x, 0, @iw, 24)
end
#--------------------------------------------------------------------------
# Resgate da informação da primeira coluna
#--------------------------------------------------------------------------
def top_column
# Define @iw (icon width: largura do ícone) para organização
@iw = (320 / 6) - (32 / 6)
return self.ox / @iw
end
#--------------------------------------------------------------------------
# Configuração da primeira coluna
# column : exibição da primeira coluna
#--------------------------------------------------------------------------
def top_column=(column)
if column < 0
column = 0
end
if column > column_max - 1
column = column_max - 1
end
self.ox = column * @iw
end
#--------------------------------------------------------------------------
# Máximo de colunas em uma página
#--------------------------------------------------------------------------
def page_column_max
return 6
end
end
#==============================================================================
# Window_MapName
#------------------------------------------------------------------------------
# Janela que exibe o nome do mapa no jogo.
#==============================================================================
class Window_MapName < Window_Base
#--------------------------------------------------------------------------
# Inclusão das constantes do módulo PANDA_MH
#--------------------------------------------------------------------------
include PANDA_MH
#--------------------------------------------------------------------------
# Inicialização do objeto
# x : coordenada X da janela
# y : coordenada Y da janela
#--------------------------------------------------------------------------
def initialize(x, y)
super(x, y, 320, 24 + 32)
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.name = $fontface
self.active = MAPNAME_ACTIVE
self.visible = MAPNAME_ACTIVE
self.back_opacity = MENU_OPACITY
refresh
end
#--------------------------------------------------------------------------
# Atualização de tela
#--------------------------------------------------------------------------
def update
super
end
#--------------------------------------------------------------------------
# Atualização
#--------------------------------------------------------------------------
def refresh
self.contents.clear
icon = RPG::Cache.icon(MAPNAME_ICON)
rect = Rect.new(0, 0, icon.width, icon.height)
self.contents.blt(0, 0, icon, rect)
self.contents.font.name = MENU_FONT
self.contents.font.size = MENU_FONT_SIZE
self.contents.draw_text(24 + 8, 0, 320 - 32 - 24 + 8, 24, $game_map.map_name.to_s)
end
end
#==============================================================================
# Window_HorizontalMenuStatus
#------------------------------------------------------------------------------
# Janela que exibe os status dos membros da equipe no menu.
#==============================================================================
class Window_HorizontalMenuStatus < Window_HorizontalSelectable
#--------------------------------------------------------------------------
# Inclusão das constantes do módulo PANDA_MH
#--------------------------------------------------------------------------
include PANDA_MH
#--------------------------------------------------------------------------
# Inicialização do objeto
# x : coordenada X da janela
# y : coordenada Y da janela
#--------------------------------------------------------------------------
def initialize(x, y)
@selection_rect = false
@selection_x = 0
super(x, y, 640, 368)
self.active = false
self.index = -1
self.back_opacity = MENU_OPACITY
# Define @fw (face width: largura da face) para organização
@fw = 640 / 4 - 8
width = 640
extra_width = (@fw * ($game_party.actors.size - 4))
if $game_party.actors.size > 0
width += extra_width
end
self.contents = Bitmap.new(width - 32, height - 32)
self.width = 640
refresh
end
#--------------------------------------------------------------------------
# Atualização
#--------------------------------------------------------------------------
def refresh
self.contents.clear
if @selection_rect
color = Color.new(0, 0, 0, 160)
self.contents.fill_rect(@selection_x, 24, @fw, 96, color)
end
@item_max = $game_party.actors.size
# Define @fw (face width: largura da face) para organização
@fw = 640 / 4 - 6
for actor in $game_party.actors
# Exibição dos nomes dos personagens
self.contents.font.color = system_color
self.contents.font.name = MENU_FONT
self.contents.font.size = MENU_FONT_SIZE
self.contents.draw_text(actor.index * @fw - 6, 0, @fw, 24, actor.name, 1)
# Exibição dos arquivos de gráfico dos personagens
draw_actor_graphic(actor, actor.index * @fw + 72, 96)
# Exibição das classes dos personagens
self.contents.font.color = normal_color
self.contents.draw_text(actor.index * @fw - 6, 96 + 24, @fw, 24, actor.class_name, 1)
# Exibição do estado físico dos personagens
text = make_battler_state_text(actor, @fw, true)
self.contents.font.color = actor.hp == 0 ? knockout_color : normal_color
self.contents.draw_text(actor.index * @fw - 6, 24 * 2 + 96, @fw, 24, text, 1)
# Exibição da nível dos personagens
draw_actor_exp_menu(actor, actor.index * @fw, 24 * 3 + 96, @fw - 8)
# Exibição do HP dos personagens
draw_actor_hp_menu(actor, actor.index * @fw, 24 * 5 + 96, @fw - 8)
# Exibição do MP dos personagens
draw_actor_mp_menu(actor, actor.index * @fw, 24 * 6 + 96, @fw - 8)
end
end
#--------------------------------------------------------------------------
# Definição do retângulo de seleção
#--------------------------------------------------------------------------
def set_selection_rect(index)
@selection_rect = true
@selection_x = index * @fw
refresh
end
#--------------------------------------------------------------------------
# Limpar retângulo de seleção
#--------------------------------------------------------------------------
def clear_selection_rect
@selection_rect = false
refresh
end
#--------------------------------------------------------------------------
# Atualização do cursor
#--------------------------------------------------------------------------
def update_cursor
if @index < 0 # Sem cursor
self.cursor_rect.empty
return
end
# Adquirir primeira coluna
column = @index / @row_max
if column < self.top_column
self.top_column = column
end
# Reiniciar para a primeira coluna se no fim da lista
if column > self.top_column + (self.page_column_max - 1)
self.top_column = column - (self.page_column_max - 1)
end
x = @index / @row_max * @fw - self.ox
# Definição do cursor
self.cursor_rect.set(x, 24, @fw - 6, 96)
end
#--------------------------------------------------------------------------
# Resgate da informação da primeira coluna
#--------------------------------------------------------------------------
def top_column
# Define @fw (face width: largura da face) para organização
@fw = 640 / 4 - 6
return self.ox / @fw
end
#--------------------------------------------------------------------------
# Configuração da primeira coluna
# column : exibição da primeira coluna
#--------------------------------------------------------------------------
def top_column=(column)
if column < 0
column = 0
end
if column > column_max - 1
column = column_max - 1
end
self.ox = column * @fw
end
#--------------------------------------------------------------------------
# Máximo de colunas em uma página
#--------------------------------------------------------------------------
def page_column_max
return 4
end
end
#==============================================================================
# Window_MenuGold
#------------------------------------------------------------------------------
# Janela responsável pela exibição do dinheiro no menu.
#==============================================================================
class Window_MenuGold < Window_Base
#--------------------------------------------------------------------------
# Inclusão das constantes do módulo PANDA_MH
#--------------------------------------------------------------------------
include PANDA_MH
#--------------------------------------------------------------------------
# Inicialização do objeto
# x : coordenada X da janela
# y : coordenada Y da janela
#--------------------------------------------------------------------------
def initialize(x, y)
super(x, y, 213, 24 + 32)
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.name = $fontface
self.active = GOLD_ACTIVE
self.visible = GOLD_ACTIVE
self.back_opacity = MENU_OPACITY
refresh
end
#--------------------------------------------------------------------------
# Atualização
#--------------------------------------------------------------------------
def refresh
self.contents.clear
self.contents.font.name = MENU_FONT
self.contents.font.size = MENU_FONT_SIZE
icon = RPG::Cache.icon(GOLD_ICON)
rect = Rect.new(0, 0, icon.width, icon.height)
self.contents.blt(0, 0, icon, rect)
draw_currency_value($game_party.gold, 0, 0, 213 - 24 - 8)
end
end
#==============================================================================
# Window_Steps
#------------------------------------------------------------------------------
# Janela responsável pela exibição dos passos.
#==============================================================================
class Window_StepsMenu < Window_Base
#--------------------------------------------------------------------------
# Inclusão das constantes do módulo PANDA_MH
#--------------------------------------------------------------------------
include PANDA_MH
#--------------------------------------------------------------------------
# Inicialização do objeto
# x : coordenada X da janela
# y : coordenada Y da janela
#--------------------------------------------------------------------------
def initialize(x, y)
super(x, y, 214, 24 + 32)
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.name = $fontface
self.active = STEPS_ACTIVE
self.visible = STEPS_ACTIVE
self.back_opacity = MENU_OPACITY
refresh
end
#--------------------------------------------------------------------------
# Atualização
#--------------------------------------------------------------------------
def refresh
self.contents.clear
icon = RPG::Cache.icon(STEPS_ICON)
rect = Rect.new(0, 0, icon.width, icon.height)
self.contents.blt(0, 0, icon, rect)
self.contents.font.name = MENU_FONT
self.contents.font.size = MENU_FONT_SIZE
draw_currency_steps_value($game_party.steps, 0, 0, 213 - 24 - 8)
end
end
#==============================================================================
# Window_PlayTime
#------------------------------------------------------------------------------
# Janela responsável pela exibição do tempo de jogo.
#==============================================================================
class Window_PlayTimeMenu < Window_Base
#--------------------------------------------------------------------------
# Inclusão das constantes do módulo PANDA_MH
#--------------------------------------------------------------------------
include PANDA_MH
#--------------------------------------------------------------------------
# Inicialização do objeto
#--------------------------------------------------------------------------
def initialize(x, y)
super(x, y, 213, 24 + 32)
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.name = $fontface
self.active = TIME_ACTIVE
self.visible = TIME_ACTIVE
self.back_opacity = MENU_OPACITY
refresh
end
#--------------------------------------------------------------------------
# Atualização
#--------------------------------------------------------------------------
def refresh
self.contents.clear
@total_sec = Graphics.frame_count / Graphics.frame_rate
hour = @total_sec / 60 / 60
min = @total_sec / 60 % 60
sec = @total_sec % 60
text = sprintf("%02d:%02d:%02d", hour, min, sec)
self.contents.font.color = normal_color
self.contents.font.name = MENU_FONT
self.contents.font.size = MENU_FONT_SIZE
icon = RPG::Cache.icon(TIME_ICON)
rect = Rect.new(0, 0, icon.width, icon.height)
self.contents.blt(0, 0, icon, rect)
self.contents.draw_text(0, 0, 213 - 24 - 8, 24, text, 2)
end
#--------------------------------------------------------------------------
# Atualização da tela
#--------------------------------------------------------------------------
def update
super
if Graphics.frame_count / Graphics.frame_rate != @total_sec
refresh
end
end
end
#==============================================================================
# Scene_Menu
#------------------------------------------------------------------------------
# Classe de operações na tela do menu.
#==============================================================================
class Scene_Menu < Scene_Base
#--------------------------------------------------------------------------
# Inclusão das contantes do módulo PANDA_MH
#--------------------------------------------------------------------------
include PANDA_MH
#--------------------------------------------------------------------------
# Criação do background do menu
#--------------------------------------------------------------------------
unless MENU_BACK == "" or MENU_BACK == '' or MENU_BACK == nil
def create_menu_background
@menuback_sprite = Plane.new
viewport = Viewport.new(0, 0, 640, 480)
@menuback_sprite.bitmap = RPG::Cache.panorama(MENU_BACK, 255)
update_menu_background
end
end
#--------------------------------------------------------------------------
# Alias da inicialização do objeto
#--------------------------------------------------------------------------
alias horizontal_menu_initialize initialize
#--------------------------------------------------------------------------
# Inicialização do objeto
# menu_index : posição inicial do cursor
#--------------------------------------------------------------------------
def initialize(menu_index = 0)
@menu_index = menu_index
end
#--------------------------------------------------------------------------
# Alias da inicialização do processo
#--------------------------------------------------------------------------
alias horizontal_menu_start start
#--------------------------------------------------------------------------
# Inicialização do processo
#--------------------------------------------------------------------------
def start
super
create_menu_background
create_command_window
@mapname_window = Window_MapName.new(320, 0)
@status_window = Window_HorizontalMenuStatus.new(0, 56)
@gold_window = Window_MenuGold.new(0, 424)
@steps_window = Window_StepsMenu.new(213, 424)
@playtime_window = Window_PlayTimeMenu.new(427, 424)
end
#--------------------------------------------------------------------------
# Alias do fim do processo
#--------------------------------------------------------------------------
alias horizontal_menu_terminate terminate
#--------------------------------------------------------------------------
# Fim do processo
#--------------------------------------------------------------------------
def terminate
super
dispose_menu_background
@command_window.dispose
@mapname_window.dispose
@status_window.dispose
@gold_window.dispose
@steps_window.dispose
@playtime_window.dispose
end
#--------------------------------------------------------------------------
# Alias da atualização de tela
#--------------------------------------------------------------------------
alias horizontal_menu_update update
#--------------------------------------------------------------------------
# Atualização da tela
#--------------------------------------------------------------------------
def update
super
update_menu_background
@command_window.update
@mapname_window.update
@status_window.update
@gold_window.update
@steps_window.update
@playtime_window.update
if @command_window.active
update_command_selection
elsif @status_window.active
update_actor_selection
end
end
#--------------------------------------------------------------------------
# Criação da janela de comandos
#--------------------------------------------------------------------------
def create_command_window
@command_window = Window_MenuCommand.new(0, 0)
@command_window.index = @menu_index
if $game_party.actors.size == 0 # Se não houver membros na equipe
@command_window.draw_item(0, false) # Desabilita "Items"
@command_window.draw_item(1, false) # Desabilita "Habilidades"
@command_window.draw_item(2, false) # Desabilita "Equipamentos"
@command_window.draw_item(3, false) # Desabilita "Status"
end
if $game_system.save_disabled # Se salvar for proibido
@command_window.draw_item(4, false) # Desabilita "Salvar"
end
end
#--------------------------------------------------------------------------
# Atualização da escolha de comando
#--------------------------------------------------------------------------
def update_command_selection
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
$scene = Scene_Map.new
elsif Input.trigger?(Input::C)
if $game_party.actors.size == 0 and @command_window.index < 4
$game_system.se_play($data_system.buzzer_se)
return
elsif $game_system.save_disabled and @command_window.index == 4
$game_system.se_play($data_system.buzzer_se)
return
end
$game_system.se_play($data_system.decision_se)
case @command_window.index
when 0 # Item
$scene = Scene_Item.new
when 1, 2, 3 # Habilidades, equipamento, status
start_actor_selection
when 4 # Salvar
$scene = Scene_Save.new
when 5 # Fim de jogo
$scene = Scene_End.new
end
end
end
#--------------------------------------------------------------------------
# Início da seleção de herói
#--------------------------------------------------------------------------
def start_actor_selection
@command_window.active = false
@status_window.active = true
@status_window.index = 0
end
#--------------------------------------------------------------------------
# Fim da seleção de herói
#--------------------------------------------------------------------------
def end_actor_selection
@command_window.active = true
@status_window.active = false
@status_window.index = - 1
end
#--------------------------------------------------------------------------
# Atualização da seleção de herói
#--------------------------------------------------------------------------
def update_actor_selection
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
end_actor_selection
elsif Input.trigger?(Input::C)
$game_system.se_play($data_system.decision_se)
case @command_window.index
when 1 # Habilidades
$scene = Scene_Skill.new(@status_window.index)
when 2 # Equipamento
$scene = Scene_Equip.new(@status_window.index)
when 3 # Status
$scene = Scene_Status.new(@status_window.index)
end
end
end
end
end # Fim da definição
#--------------------------------------------------------------------------
# Definição da utiização do Menu Horizontal Status
#--------------------------------------------------------------------------
unless PANDA_MH::HORIZONTAL_MENU_STATUS != true
#==============================================================================
# Window_Status
#------------------------------------------------------------------------------
# Janela que exibe os status dos personagens.
#==============================================================================
class Window_Status < Window_Base
#--------------------------------------------------------------------------
# Inclusão das constantes do módulo PANDA_MH
#--------------------------------------------------------------------------
include PANDA_MH
#--------------------------------------------------------------------------
# Alias da inicialização do objeto
#--------------------------------------------------------------------------
alias horizontal_menu_initialize initialize
#--------------------------------------------------------------------------
# Inicialização do objeto
#--------------------------------------------------------------------------
def initialize(actor)
# Roda o método original
horizontal_menu_initialize(actor)
self.back_opacity = STATUS_OPACITY
end
#--------------------------------------------------------------------------
# Alias da atualização
#--------------------------------------------------------------------------
alias horizontal_menu_status_refresh refresh
#--------------------------------------------------------------------------
# Atualização
#--------------------------------------------------------------------------
def refresh
self.contents.clear
# Exibição do perfil do herói
draw_actor_profile
# Exibição da informação básica do herói
draw_basic_info
# Exibição dos parâmetros do herói
draw_parameters
# Exibição do equipamento do herói
draw_equipments
# Exibição de informações adicionais
draw_extra
end
#--------------------------------------------------------------------------
# Exibição do perfil do herói
#--------------------------------------------------------------------------
def draw_actor_profile
# Define @fw (face width: largura da face) para organização
@fw = 544 / 4 - 8
# Cria um retângulo
rect = Rect.new(0, 0, @fw, 96 + (2 * 24))
# Define o retângulo como circular
self.contents.fill_rounded_rect(rect, system_color, 10)
# Define novos valores para x e y
rect.x, rect.y = rect.x + 2, rect.y + 2
# Define novos valores para largura e altura
rect.width, rect.height = rect.width - 4, rect.height - 4
# Define um novo retângulo circular com os novos valores
self.contents.fill_rounded_rect(rect, Color.new (0, 0, 0, 0), 10)
# Cria um retângulo
rect = Rect.new(0, 24, @fw, 96)
# Preenche o retângulo
self.contents.fill_rect(rect, system_color)
# Define novos valores para x e y
rect.x, rect.y = rect.x + 2, rect.y + 2
# Define novos valores para largura e altura
rect.width, rect.height = rect.width - 4, rect.height - 4
# Define um novo retângulo com os novos valores
self.contents.fill_rect(rect, Color.new (0, 0, 0, 0))
# Exibição do nome do herói
self.contents.font.name = STATUS_FONT
self.contents.font.size = STATUS_FONT_SIZE
self.contents.font.color = system_color
self.contents.draw_text(0, 0, @fw, 24, @actor.name, 1)
# Exibição dos arquivos de faces dos personagens
bitmap = RPG::Cache.character(@actor.character_name, @actor.character_hue)
cw = bitmap.width / 4
ch = bitmap.height / 4
src_rect = Rect.new(0, 0, cw, ch)
self.contents.blt(48, 48, bitmap, src_rect)
# draw_face(@actor.face_name, @actor.face_index, 16, 24, 96)
# Exibição do nome da classe do herói
self.contents.font.color = normal_color
self.contents.draw_text(0, 96 + 24, @fw, 24, @actor.class_name, 1)
end
#--------------------------------------------------------------------------
# Exibição de informações básicas
# x : exibe na coordenada X
# y : exibe na coordenada Y
#--------------------------------------------------------------------------
def draw_basic_info
# Cria um retângulo
rect = Rect.new(@fw + 32 - 16, 0, 640 - (@fw + 32) - 16, 96 + (2 * 24))
# Define o retângulo como circular
self.contents.fill_rounded_rect(rect, system_color, 10)
# Define novos valores para x e y
rect.x, rect.y = rect.x + 2, rect.y + 2
# Define novos valores para largura e altura
rect.width, rect.height = rect.width - 4, rect.height - 4
# Define um novo retângulo circular com os novos valores
self.contents.fill_rounded_rect(rect, Color.new (0, 0, 0, 0), 10)
# Cria um retângulo
rect = Rect.new(@fw + 32 - 16, 24, 640 - (@fw + 32) - 16, 96)
# Preenche o retângulo
self.contents.fill_rect(rect, system_color)
# Define novos valores para x e y
rect.x, rect.y = rect.x + 2, rect.y + 2
# Define novos valores para largura e altura
rect.width, rect.height = rect.width - 4, rect.height - 4
# Define um novo retângulo com os novos valores
self.contents.fill_rect(rect, Color.new (0, 0, 0, 0))
# Exibição do nome Status
self.contents.font.color = system_color
self.contents.draw_text(@fw + 32 - 16, 0, 640 - (@fw + 32) - 16, 24, "Status", 1)
self.contents.font.color = normal_color
# Exibição da nível dos personagens
draw_actor_exp_menu(@actor, @fw + 32, 24, @fw - 8)
# Exibição do HP dos personagens
draw_actor_hp_menu(@actor, @fw + 32, 24 * 2, @fw - 8)
# Exibição do MP dos personagens
draw_actor_mp_menu(@actor, @fw + 32, 24 * 3, @fw - 8)
# Exibição do estado físico dos personagens
draw_actor_state(@actor, @fw + 32, 24 * 5 - 4, 640 - (@fw + 32) - 48)
# Define a string para a experiência total e restante para o próximo nível
s1 = @actor.exp_s
s2 = @actor.next_rest_exp_s
s_next = sprintf(Vocab::ExpNext, Vocab.level)
# Exibição da experiência total e restante para o próximo nível
self.contents.font.color = system_color
self.contents.draw_text(2 * @fw + 160 , 24, 180, 24, Vocab::ExpTotal)
self.contents.draw_text(2 * @fw + 160, 24 * 3, 180, 24, s_next)
self.contents.font.color = normal_color
self.contents.draw_text(2 * @fw + 160, 24 * 2, 180, 24, s1, 2)
self.contents.draw_text(2 * @fw + 160, 24 * 4, 180, 24, s2, 2)
end
#--------------------------------------------------------------------------
# Exibição dos parâmetros
# x : exibe na coordenada X
# y : exibe na coordenada Y
#--------------------------------------------------------------------------
def draw_parameters
# Cria um retângulo
rect = Rect.new(0, 96 + (2 * 24) + 16, 640 / 2 - 24, 480 - (96 + (2 * 24)) - 48 - 80)
# Define o retângulo como circular
self.contents.fill_rounded_rect(rect, system_color, 10)
# Define novos valores para x e y
rect.x, rect.y = rect.x + 2, rect.y + 2
# Define novos valores para largura e altura
rect.width, rect.height = rect.width - 4, rect.height - 4
# Define um novo retângulo circular com os novos valores
self.contents.fill_rounded_rect(rect, Color.new (0, 0, 0, 0), 10)
# Cria um retângulo
rect = Rect.new(0, 96 + (3 * 24) + 16, 640 / 2 - 24, 2)
# Preenche o retângulo
self.contents.fill_rect(rect, system_color)
# Exibição do nome Parâmetros
self.contents.font.color = system_color
self.contents.draw_text(0, 96 + (2 * 24) + 16, 640 / 2 - 24, 24, "Parâmetros", 1)
self.contents.font.color = normal_color
# Exibição dos parâmetros dos personagens
draw_actor_parameter_menu(@actor, 70, 96 + (2 * 24) + 16 + (24 * 1), 0)
draw_actor_parameter_menu(@actor, 70, 96 + (2 * 24) + 16 + (24 * 2), 1)
draw_actor_parameter_menu(@actor, 70, 96 + (2 * 24) + 16 + (24 * 3), 2)
draw_actor_parameter_menu(@actor, 70, 96 + (2 * 24) + 16 + (24 * 4), 3)
draw_actor_parameter_menu(@actor, 70, 96 + (2 * 24) + 16 + (24 * 5), 4)
draw_actor_parameter_menu(@actor, 70, 96 + (2 * 24) + 16 + (24 * 6), 5)
draw_actor_parameter_menu(@actor, 70, 96 + (2 * 24) + 16 + (24 * 7), 6)
end
#--------------------------------------------------------------------------
# Exibição dos equipamentos
# x : exibe na coordenada X
# y : exibe na coordenada Y
#--------------------------------------------------------------------------
def draw_equipments
# Cria um retângulo
rect = Rect.new(640 / 2 - 8, 96 + (2 * 24) + 16, 640 / 2 - 24, 480 - (96 + (5 * 24)) - 48 - 64)
# Define o retângulo como circular
self.contents.fill_rounded_rect(rect, system_color, 10)
# Define novos valores para x e y
rect.x, rect.y = rect.x + 2, rect.y + 2
# Define novos valores para largura e altura
rect.width, rect.height = rect.width - 4, rect.height - 4
# Define um novo retângulo circular com os novos valores
self.contents.fill_rounded_rect(rect, Color.new (0, 0, 0, 0), 10)
# Cria um retângulo
rect = Rect.new(640 / 2 - 8, 96 + (3 * 24) + 16, 640 / 2 - 24, 2)
# Preenche o retângulo
self.contents.fill_rect(rect, system_color)
# Exibição do nome Equipamento
self.contents.font.color = system_color
self.contents.draw_text(640 / 2 - 8, 96 + (2 * 24) + 16, 640 / 2 - 24, 24, Vocab.equip, 1)
# Exibição dos nomes dos tipos de equipamentos
self.contents.draw_text(640 / 2 - 8 + 16, 96 + (3 * 24) + 16, 640 / 2 - 24 - 172, 24, $data_system.words.weapon + ":")
self.contents.draw_text(640 / 2 - 8 + 16, 96 + (4 * 24) + 16, 640 / 2 - 24 - 172, 24, $data_system.words.armor1 + ":")
self.contents.draw_text(640 / 2 - 8 + 16, 96 + (5 * 24) + 16, 640 / 2 - 24 - 172, 24, $data_system.words.armor2 + ":")
self.contents.draw_text(640 / 2 - 8 + 16, 96 + (6 * 24) + 16, 640 / 2 - 24 - 172, 24, $data_system.words.armor3 + ":")
self.contents.draw_text(640 / 2 - 8 + 16, 96 + (7 * 24) + 16, 640 / 2 - 24 - 172, 24, $data_system.words.armor4 + ":")
# Exibição dos equipamentos do herói
draw_item_name($data_weapons[@actor.weapon_id], 640 - 172 - 48, (96 + (2 * 24) + 16) + 24 * (0 + 1))
draw_item_name($data_armors[@actor.armor1_id], 640 - 172 - 48, (96 + (2 * 24) + 16) + 24 * (1 + 1))
draw_item_name($data_armors[@actor.armor2_id], 640 - 172 - 48, (96 + (2 * 24) + 16) + 24 * (2 + 1))
draw_item_name($data_armors[@actor.armor3_id], 640 - 172 - 48, (96 + (2 * 24) + 16) + 24 * (3 + 1))
draw_item_name($data_armors[@actor.armor4_id], 640 - 172 - 48, (96 + (2 * 24) + 16) + 24 * (4 + 1))
end
#--------------------------------------------------------------------------
# Exibição das informações adicional
#--------------------------------------------------------------------------
def draw_extra
# Cria um retângulo
rect = Rect.new(640 / 2 - 8, 2 * (96 + (2 * 24) + 20) + 64, 640 / 2 - 24, 480 - (2 * (96 + (5 * 24) - 36)) - 64)
# Define o retângulo como circular
self.contents.fill_rounded_rect(rect, system_color, 10)
# Define novos valores para x e y
rect.x, rect.y = rect.x + 2, rect.y + 2
# Define novos valores para largura e altura
rect.width, rect.height = rect.width - 4, rect.height - 4
# Define um novo retângulo circular com os novos valores
self.contents.fill_rounded_rect(rect, Color.new (0, 0, 0, 0), 10)
# Cria um retângulo
rect = Rect.new(640 / 2 - 8, 2 * (96 + (2 * 24) + 20) + 24 + 64, 640 / 2 - 24, 2)
# Preenche o retângulo
self.contents.fill_rect(rect, system_color)
self.contents.font.color = system_color
self.contents.draw_text(640 / 2 - 8, 2 * (96 + (2 * 24) + 20) + 64, 640 / 2 - 24, 24, "Pressione", 1)
self.contents.draw_text(640 / 2 - 8, 2 * (96 + (2 * 24) + 20) + 24 + 4 + 64, 640 / 2 - 24, 24, "← Anterior | Próximo →", 1)
end
end
#==============================================================================
# Scene_Status
#------------------------------------------------------------------------------
# Classe de operações na tela de status.
#==============================================================================
class Scene_Status < Scene_Base
#--------------------------------------------------------------------------
# Inclusão das contantes do módulo PANDA_MH
#--------------------------------------------------------------------------
include PANDA_MH
#--------------------------------------------------------------------------
# Criação do background do menu
#--------------------------------------------------------------------------
unless STATUS_BACK == "" or STATUS_BACK == '' or STATUS_BACK == nil
def create_menu_background
@menuback_sprite = Plane.new
viewport = Viewport.new(0, 0, 640, 480)
@menuback_sprite.bitmap = RPG::Cache.panorama(STATUS_BACK, 255)
update_menu_background
end
end
#--------------------------------------------------------------------------
# Inicialização do objeto
# actor_index : index do herói
#--------------------------------------------------------------------------
def initialize(actor_index = 0)
@actor_index = actor_index
end
#--------------------------------------------------------------------------
# Inicialização do processo
#--------------------------------------------------------------------------
def start
super
create_menu_background
@actor = $game_party.actors[@actor_index]
@status_window = Window_Status.new(@actor)
end
#--------------------------------------------------------------------------
# Fim do processo
#--------------------------------------------------------------------------
def terminate
super
dispose_menu_background
@status_window.dispose
end
#--------------------------------------------------------------------------
# Retornar à tela original
#--------------------------------------------------------------------------
def return_scene
$scene = Scene_Menu.new(3)
end
#--------------------------------------------------------------------------
# Troca para a tela do próximo herói
#--------------------------------------------------------------------------
def next_actor
@actor_index += 1
@actor_index %= $game_party.actors.size
$scene = Scene_Status.new(@actor_index)
end
#--------------------------------------------------------------------------
# Troca para a tela do herói anterior
#--------------------------------------------------------------------------
def prev_actor
@actor_index += $game_party.actors.size - 1
@actor_index %= $game_party.actors.size
$scene = Scene_Status.new(@actor_index)
end
#--------------------------------------------------------------------------
# Atualização
#--------------------------------------------------------------------------
def update
update_menu_background
@status_window.update
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
return_scene
elsif Input.trigger?(Input::R)
$game_system.se_play($data_system.cursor_se)
next_actor
elsif Input.trigger?(Input::L)
$game_system.se_play($data_system.cursor_se)
prev_actor
elsif Input.trigger?(Input::RIGHT)
$game_system.se_play($data_system.cursor_se)
next_actor
elsif Input.trigger?(Input::LEFT)
$game_system.se_play($data_system.cursor_se)
prev_actor
end
super
end
end
endInstrucciones:
Pegar encima del main y configurar a su gus
?)
