#============================================================================== # Menu Horizontal [VX] #------------------------------------------------------------------------------ # Modifica o menu padrão do RPG Maker VX e adiciona algumas novas janelas. #------------------------------------------------------------------------------ # Site : http://www.mundorpgmaker.com.br/ # Autor : Kyo Panda # Versão : 2.3 # Atualização : 11 de Maio de 2011 # Lançado em : 21 de Janeiro de 2010 #============================================================================== #============================================================================== # Agradecimentos: #------------------------------------------------------------------------------ # • Woratana : Pela criação da classe Ellipse, utilizada para criar os # retãngulos com pontas arredondadas. # • M@pple : Pela ideia da mudança das faces de menu por chars e vice-versa. # Pela ideia de definir as Windowskins da janela do menu. E pela a ajuda na # procura de bugs. # • Ælly : Pela ideia de inserir imagens ao invés de faces no menu. E pela # ideia do efeito flash na seleção dos personagens. #============================================================================== #============================================================================== # Como usar: #------------------------------------------------------------------------------ # # #-------------------------------------------------------------------------- # # Instalação # #-------------------------------------------------------------------------- # # • Cole o script acima do "▼ Principal" e abaixo dos "▼ Scripts Adicionais" # no Editor de Scripts do RPG Maker VX. # # • Configure o script no guia "Configuração" logo abaixo. # #============================================================================== #============================================================================== # Histórico de versões: #------------------------------------------------------------------------------ # • Versão 2.3, 11 de Maio de 2011: # * Correção do bug da tela de itens. # • Versão 2.2, 12 de Fevereiro de 2011: # * Adicionado a possibilidade de customizar as funções executadas no menu. # * Adicionado a configuração do BGM do menu, assim como seus SE. # * Adicionado o efeito flash de seleção de personagens. # * Adicionado o efeito de respiração de seleção de personagens. # • Versão 2.1, 18 de Outubro de 2010: # * Adicionado a opção de colocar imagens como faces no menu. # * Adicionado a possibilidade de ocultar certas informações. # * Adicionado a opção de mudar o tamanho do retângulo de seleção. # * Adicionado a opção de mudar a Windowskin e opacidade das janelas. # * Adicionado a opção de definir um fundo de tela. # • Versão 2.0, 16 de Outubro de 2010: # * Script completamente remodelado. # * Adicionado à opção de trocar entre faces ou chars no menu. # • Versão 1.1, 25 de Janeiro de 2010: # * Corrigido o bug da janela de dinheiro com tamanhos incorretos em outras # telas. # * Adicionado a tela de status customizada. # * Adicionado suporte para grupos grandes. # • Versão 1.0, 21 de Janeiro de 2010: # * Primeira versão do Menu Horizontal. #============================================================================== #============================================================================== # KPMH_Settings #------------------------------------------------------------------------------ # Módulo de configurações para o script KP Menu Horizontal. #============================================================================== module KPMH_Settings #------------------------------------------------------------------------- # Início da configuração #------------------------------------------------------------------------- # Defina aqui quais menus do Menu Horizontal serão utilizados ou não. # Defina true para sim e false para não. MAIN_MENU = true # Menu Principal STATUS_MENU = true # Menu de Status # Defina aqui as imagens de background dos menus contidos na pasta # Graphics/System do seu projeto. # Defina o nome das imagens entre aspas ("") ou apóstrofes ('') # Defina como "", '' ou nil para não utilizar. MAIN_MENU_BACKGROUND = "" # Menu Principal STATUS_MENU_BACKGROUND = "" # Menu de Status # Deina aqui o ícone de cada comando do menu principal. Segue-se o # seguinte para definí-los: ID => Index, onde ID é o ID da opção e Index # o index do ícone no Iconset COMMANDS_SETTINGS = { # ID => Index 0 => 144, # Itens 1 => 128, # Habilidades 2 => 40, # Equipamento 3 => 132, # Status 4 => 133, # Salvar 5 => 137, # Sair } # Não remova isto! # Configure aqui as ações tomadas pelo RPG Maker quando um determinado # index do menu for selecionado. # # ID => [FUN, NEC], # # ID : Index do comando # FUN : Função executada # NEC : Necessidade para que a função seja executada # # Se a função for sempre ativa, defina NEC como "" ou ''. COMMANDS_FUNCTION = { # ID => [ FUN , NEC ], 0 => ["$scene = Scene_Item.new", "$game_party.members.size > 0"], 1 => ["start_actor_selection" , "$game_party.members.size > 0"], 2 => ["start_actor_selection" , "$game_party.members.size > 0"], 3 => ["start_actor_selection" , "$game_party.members.size > 0"], 4 => ["$scene = Scene_File.new(true, false, false)", "!$game_system.save_disabled"], 5 => ["$scene = Scene_End.new" , "" ], } # Não remova isto! # Configure aqui as ações tomadas pelo RPG Maker quando um determinado # index do menu de seleção de personagens for executado. # # ID => [FUN], # # ID : Index da janela de comandos (não a dos personagens) # FUN : Função executada ACTORS_FUNCTION = { # ID => FUN 1 => "$scene = Scene_Skill.new(@status_window.index)", 2 => "$scene = Scene_Equip.new(@status_window.index)", 3 => "$scene = Scene_Status.new(@status_window.index)", } # Não remova isto! # 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", "UmePlus Gothic", "Verdana"] # Defina aqui a música de fundo que será reproduzida no menu. # O arquivo de música deve estar na pasta Audio/BGM do seu projeto. # Defina o nome entre aspas ("") ou apóstrofes (''). # Defina como "", '' ou nil para não utilizar esta função MENU_BGM = "Scene7" # Defina aqui o modo em que as figuras dos personagens devem ser exibidas # no menu. 0 : Faces, 1 : Chars, 2 : Faces e Chars e 3 : Imagens STATUS_WINDOW_MODE = 2 # Menu Principal STATUS_MENU_WINDOW_MODE = 2 # Menu de Status # Se escolher o modo das figuras dos personagens como imagens, defina aqui # as imagens utilizadas: # O modo de utilizar é ID_do_Personagem => "Imagem", STATUS_WINDOW_IMAGES = { # ID => "Imagem", # 1 => "Face001", # 2 => "Face002", # 3 => "Face003", # 4 => "Face004", } # Não remova isto # Defina aqui o posicionamento vertical e a altura do cursor no menu. # Desde que seu posicionamento horizontal e largura são definidos pelo # número de faces no menu. CURSOR = [ 24, 96] # Defina aqui algumas informações que talvez você deseje ocultar no menu. # Defina true para ocultar e false para exibir. HIDDEN_NAME = false # Nome HIDDEN_CLASS = false # Classe HIDDEN_STATE = false # Status HIDDEN_EXP = false # Experiência HIDDEN_HP = false # HP HIDDEN_MP = false # MP # Defina aqui as configurações para a janela de comandos e status do menu. # Segue-se o seguinte modelo para definí-los: # # [X, Y, Largura, Altura, Opacidade, Visual, Windowskin] # # X : Posicionamento horizontal da janela # Y : Posicionamento vertical da janela # Largura : Largura da janela # Altura : Altura da janela # Opacidade : Opacidade da janela # Visual : Número de opções que a janela exibe, antes do scroll # Windowskin : A Windoskin da janela, defina nil para não usar # [ X , Y , Lar, Alt, Opa, Vis, "Window"] COMMAND_WINDOW = [ 0, 0, 272, 56, 255, 6, "Window"] # Comandos STATUS_WINDOW = [ 0, 56, 544, 304, 255, 4, "Window"] # Status # Defina aqui as configurações para as janelas restantes do menu. # Segue-se o seguinte modelo para definí-los: # # [X, Y, Largura, Altura, Opacidade, Ícone, Ativo, Windowskin] # # X : Posicionamento horizontal da janela # Y : Posicionamento vertical da janela # Largura : Largura da janela # Altura : Altura da janela # Opacidade : Opacidade da janela # Ícone : Ìcone da janela, definido pelo index do Iconset # Ativo : Se está ou não visível, define true para sim e false, não # Windowskin : A Windoskin da janela, defina nil para não usar # [ X , Y , Lar, Alt, Opa, Íco, Ativo, "Window"] MAPNAME_WINDOW = [272, 0, 272, 56, 255, 153, true , "Window"] # Mapa GOLD_WINDOW = [ 0, 360, 182, 56, 255, 147, true , "Window"] # Gold STEPS_WINDOW = [181, 360, 181, 56, 255, 48, true , "Window"] # Passos TIME_WINDOW = [362, 360, 181, 56, 255, 176, true , "Window"] # Tempo # Defina aqui as propriedades da janela do menu de status. # Segue-se o seguinte modelo para definí-los: # # [X, Y, Largura, Altura, Opacidade, Windowskin] # # X : Posicionamento horizontal da janela # Y : Posicionamento vertical da janela # Largura : Largura da janela # Altura : Altura da janela # Opacidade : Opacidade da janela # Windowskin : A Windoskin da janela, defina nil para não usar # [ X , Y , Lar, Alt, Opa, "Window"] STATUS_MWINDOW = [ 0, 0, 544, 416, 255, "Window"] # Defina aqui se deseja que um efeito de flash seja executado com um # personagem é selecionado. Configurações são necessárias nos comandos # abaixo. ACTOR_FLASH_SELECTION = true # Defina aqui as propriedades do efeito flash, se assim definido acima. # As cores são definidos como Color.new(R, G, B, Opacidade) # # [CFL, DFL] # # CFL : Cor do flash # DFL : Duração do flash em frames # [ CFL , DFL] ACTOR_FLASH_SELECTION_SET = [Color.new(255, 255, 255, 255), 10] # Defina aqui se deseja utilizar ou não o efeito de respiração nos # personagens selecionandos. ACTOR_BREATH_SELECTION = true # Defina aqui a frequência e magnetude do efeito de respiração. # # [FRE, MAG] # # FRE : Frequência # MAG : Magnetude # [FRE, MAG] ACTOR_BREATH_SELECTION_SET = [ 45, 10] # Defina aqui os sons executados pelo menu. # Os sons devem estar na pasta "Audio/SE" do seu projeto. # Define os nomes dos arquivos entre aspas ("") ou apóstrofes ('') COMMAND_DECISION = "Decision1" # Som de confirmação dos comandos COMMAND_CANCEL = "Cancel" # Som de cancelamento dos comandos ACTOR_DECISION = "Saint5" # Som de confirmação do personagem ACTOR_CANCEL = "Cancel" # Som de cancelamento do personagem ERROR_SOUND = "Buzzer1" # Som de erro #------------------------------------------------------------------------- # Fim da configuração #------------------------------------------------------------------------- end #-------------------------------------------------------------------------- # Define a chave "Horizontal_Menu" na hash $kpanda_scripts como true #-------------------------------------------------------------------------- $kpanda_scripts = {} if $kpanda_scripts.nil? $kpanda_scripts["0001: Horizontal_Menu"] = true #============================================================================== # 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 # 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 #============================================================================== # 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 #============================================================================== # 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 : Posicionamento horizontal # y : Posicionamento vertical # a : Largura do círculo em sua origem do seu lado # b : 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 : Coordenada horizontal sendo testada # y : 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 #============================================================================== # Window_Base #------------------------------------------------------------------------------ # Esta é a classe superior à todas as classes de janelas do jogo. #============================================================================== class Window_Base < Window #-------------------------------------------------------------------------- # Exibição da EXP # actor : herói # x : exibe na coordenada X # y : exibe na coordenada Y # width : largura #-------------------------------------------------------------------------- def draw_actor_exp(actor, x, y, width = 120) draw_actor_exp_gauge(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, WLH, Vocab::level_a) self.contents.font.color = normal_color self.contents.draw_text(xr, y, 80, WLH, actor.level, 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(actor, x, y, width = 120) max = actor.next_max_exp gw = width * (max - actor.next_rest_exp) / max gc1 = text_color(30) gc2 = text_color(31) self.contents.fill_rect(x, y + WLH - 8, width, 6, gauge_back_color) self.contents.gradient_fill_rect(x, y + WLH - 8, gw, 6, gc1, gc2) 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, WLH, value, 2) end end #============================================================================== # Bitmap #------------------------------------------------------------------------------ # Classe que comanda toda e qualquer imagem exibida no jogo. #============================================================================== class Bitmap #-------------------------------------------------------------------------- # Exibição dos gráficos de movimento # character_name : nome do arquivo em movimento # character_index : número do arquivo em movimento # x : exibe na coordenada X destino # y : exobe na coordenada Y destino #-------------------------------------------------------------------------- def draw_character(character_name, character_index, x, y) return if character_name == nil bitmap = Cache.character(character_name) sign = character_name[/^[\!\$]./] if sign != nil and sign.include?('$') cw = bitmap.width / 3 ch = bitmap.height / 4 else cw = bitmap.width / 12 ch = bitmap.height / 8 end n = character_index src_rect = Rect.new((n%4*3+1)*cw, (n/4*4)*ch, cw, ch) self.blt(x - cw / 2, y - ch, bitmap, src_rect) end #-------------------------------------------------------------------------- # Exibição dos gráficos de face # face_name : nome do arquivo de face # face_index : número do arquivo de face # x : exibe na coordenada X # y : exibe na coordenada Y # size : exibe o tamanho #-------------------------------------------------------------------------- def draw_face(face_name, face_index, x, y, size = 96) bitmap = Cache.face(face_name) rect = Rect.new(0, 0, 0, 0) rect.x = face_index % 4 * 96 + (96 - size) / 2 rect.y = face_index / 4 * 96 + (96 - size) / 2 rect.width = size rect.height = size self.blt(x, y, bitmap, rect) bitmap.dispose end #-------------------------------------------------------------------------- # Contorno da elipse # ellipse : Elipse sendo desenhada # width : Largura da barra # colour : 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 : Elipse sendo desenhada # colour : 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 : Retângulo sendo desenhado # colour : Cor do contorno # w : Número de pixels para cobrir o círculo #-------------------------------------------------------------------------- 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 #============================================================================== # Window_HMC #------------------------------------------------------------------------------ # Janela que exibe os comandos para o script KP Menu Horizontal. #============================================================================== class Window_HMC < Window_Command #-------------------------------------------------------------------------- # Variáveis públicas #-------------------------------------------------------------------------- attr_reader :commands # Comandos #-------------------------------------------------------------------------- # Inicialização do objeto # x : Posicionamento horizontal da janela # y : Posicionamento vertical da janela # width : Largura da janela # height : Altura da janela #-------------------------------------------------------------------------- def initialize(x, y, width, height) @column_max = KPMH_Settings::COMMAND_WINDOW[5] @cell_size = (width - 32) / @column_max @index_increment = 0 @x, @y, @width, @height = x, y, width, height super(56, [""], @column_max, 1) if !KPMH_Settings::COMMAND_WINDOW[7].nil? && File.exist?("./Graphics/System/#{KPMH_Settings::COMMAND_WINDOW[6]}.png") self.windowskin = Cache.system(KPMH_Settings::COMMAND_WINDOW[6]) end self.opacity = KPMH_Settings::COMMAND_WINDOW[4] refresh end #-------------------------------------------------------------------------- # Criação do conteúdo da janela #-------------------------------------------------------------------------- def create_contents self.contents.dispose unless [self.x, self.y, self.width, self.height] == [@x, @y, @width, @height] self.x, self.y, self.width, self.height = @x, @y, @width, @height end cw = @item_max * ((width - 32) / @column_max) self.contents = Bitmap.new(cw, height - 32) end #-------------------------------------------------------------------------- # Atualização da tela #-------------------------------------------------------------------------- def update @index = 0 if @index < 0 if @index - @index_increment >= @column_max self.ox = @cell_size * (@index - @column_max + 1) @index_increment += 1 elsif @index - @index_increment < 0 self.ox = @cell_size * @index @index_increment -= 1 end super end #-------------------------------------------------------------------------- # Atualização #-------------------------------------------------------------------------- def refresh self.contents.clear @column_max = KPMH_Settings::COMMAND_WINDOW[5] @item_max = KPMH_Settings::COMMANDS_SETTINGS.size (0 .. @item_max - 1).each do |i| @commands[i] = KPMH_Settings::COMMANDS_SETTINGS[i] end create_contents (0 .. @item_max - 1).each{|i| draw_item(i)} end #-------------------------------------------------------------------------- # Desenho do item # index : Index do comando # active : Se o item está ativo ou não #-------------------------------------------------------------------------- def draw_item(index, active = true) icon_index = @commands[index] return unless icon_index.is_a?(Integer) icon_align = (@cell_size - 24) / 2 if icon_index != nil draw_icon(icon_index, @cell_size * index + icon_align , 0, active) end end #-------------------------------------------------------------------------- # Mover cursor para direita # wrap : permissão de wrap #-------------------------------------------------------------------------- def cursor_right(wrap = false) if (@index < @item_max - 1 or (wrap and page_row_max == 1)) @index = (@index + 1) % @item_max end end #-------------------------------------------------------------------------- # Mover cursor para esquerda # wrap : permissão de wrap #-------------------------------------------------------------------------- def cursor_left(wrap = false) if (@index > 0 or (wrap and page_row_max == 1)) @index = (@index - 1 + @item_max) % @item_max end end #-------------------------------------------------------------------------- # Mover cursor para baixo # wrap : permissão de wrap #-------------------------------------------------------------------------- def cursor_down(wrap = false) end #-------------------------------------------------------------------------- # Mover cursor para cima # wrap : permissão de wrap #-------------------------------------------------------------------------- def cursor_up(wrap = false) end #-------------------------------------------------------------------------- # Volta uma página com o cursor #-------------------------------------------------------------------------- def cursor_pagedown @index = [@index + page_item_max, @item_max - 1].min end #-------------------------------------------------------------------------- # Avança uma página com o cursor #-------------------------------------------------------------------------- def cursor_pageup @index = [@index - page_item_max, 0].max end #-------------------------------------------------------------------------- # Atualização do cursor #-------------------------------------------------------------------------- def update_cursor index = @index - @index_increment if !self.active # Sem cursor self.cursor_rect.empty elsif index < @item_max # Padrão self.cursor_rect.set(index * @cell_size, 0, @cell_size, WLH) elsif index >= 100 # Si self.cursor_rect.set((index - 100) * @cell_size, WLH, @cell_size, WLH) else # O todo self.cursor_rect.set(0, 0, @item_max * @cell_size, WLH) end end end #============================================================================== # Window_MapName #------------------------------------------------------------------------------ # Janela que exibe o nome do mapa no jogo. #============================================================================== class Window_MapName < Window_Base #-------------------------------------------------------------------------- # Inicialização do objeto # x : Coordenada X da janela # y : Coordenada Y da janela # width : Largura da janela # height : Altura da janela #-------------------------------------------------------------------------- def initialize(x, y, width, height) super(x, y, width, height) if !KPMH_Settings::MAPNAME_WINDOW[7].nil? && File.exist?("./Graphics/System/#{KPMH_Settings::MAPNAME_WINDOW[7]}.png") self.windowskin = Cache.system(KPMH_Settings::MAPNAME_WINDOW[7]) end self.opacity = KPMH_Settings::MAPNAME_WINDOW[4] self.visible = KPMH_Settings::MAPNAME_WINDOW[6] refresh end #-------------------------------------------------------------------------- # Atualização #-------------------------------------------------------------------------- def refresh self.contents.clear draw_icon(KPMH_Settings::MAPNAME_WINDOW[5], 0, 0) self.contents.font.name = KPMH_Settings::MENU_FONT name = load_data("Data/MapInfos.rvdata")[$game_map.map_id].name self.contents.draw_text(24 + 8, 0, contents.width - 24 + 8, WLH, name) end end #============================================================================== # Window_HMS #------------------------------------------------------------------------------ # Janela que exibe os status dos membros da equipe no menu. #============================================================================== class Window_HMS < Window_Selectable #-------------------------------------------------------------------------- # Variáveis públicas #-------------------------------------------------------------------------- attr_reader :face_sprites #-------------------------------------------------------------------------- # Inicialização do objeto # x : Coordenada X da janela # y : Coordenada Y da janela # width : Largura da janela # height : Altura da janela #-------------------------------------------------------------------------- def initialize(x, y, width, height) super(x, y, width, height) if !KPMH_Settings::STATUS_WINDOW[7].nil? && File.exist?("./Graphics/System/#{KPMH_Settings::STATUS_WINDOW[6]}.png") self.windowskin = Cache.system(KPMH_Settings::STATUS_WINDOW[6]) end self.opacity = KPMH_Settings::STATUS_WINDOW[4] @column_max = KPMH_Settings::STATUS_WINDOW[5] @cell_size = (self.width - 32) / @column_max @index_increment = 0 @commands = [] self.active = false @face_sprites = [] @breath_count = 0 @breath_incresing = false refresh end #-------------------------------------------------------------------------- # Criação do conteúdo da janela #-------------------------------------------------------------------------- def create_contents self.contents.dispose cw = @item_max * ((width - 32) / @column_max) self.contents = Bitmap.new(cw, height - 32) end #-------------------------------------------------------------------------- # Dispose #-------------------------------------------------------------------------- def dispose super @face_sprites.each{|i| i.dispose} if !@face_sprites.empty? end #-------------------------------------------------------------------------- # Atualização da tela #-------------------------------------------------------------------------- def update @index = 0 if @index < 0 if @index - @index_increment >= @column_max self_ox = self.ox self.ox = @cell_size * (@index - @column_max + 1) @index_increment += 1 if !@face_sprites.empty? @face_sprites.each{|i| i.x -= (self.ox - self_ox)} @face_sprites.each_index do |i| if @face_sprites[i].x >= self.x + 16 && @face_sprites[i].x <= self.x + self.width - 16 @face_sprites[i].visible = true else @face_sprites[i].visible = false end end end elsif @index - @index_increment < 0 self_ox = self.ox self.ox = @cell_size * @index @index_increment -= 1 if !@face_sprites.empty? @face_sprites.each{|i| i.x -= (self.ox - self_ox)} @face_sprites.each_index do |i| if @face_sprites[i].x >= self.x + 16 && @face_sprites[i].x <= self.x + self.width - 16 @face_sprites[i].visible = true else @face_sprites[i].visible = false end end end end super # Atualização do efeito de respiração if KPMH_Settings::ACTOR_BREATH_SELECTION && self.active if !@face_sprites[@index].nil? @breath_count += 1 if @breath_count >= Graphics.frame_rate / KPMH_Settings::ACTOR_BREATH_SELECTION_SET[0].to_f @breath_count = 0 if @breath_increasing @face_sprites[@index].zoom_x += 0.01 @face_sprites[@index].zoom_y += 0.01 if @face_sprites[@index].zoom_x >= 1 @breath_increasing = false end else @face_sprites[@index].zoom_x -= 0.01 @face_sprites[@index].zoom_y -= 0.01 if @face_sprites[@index].zoom_x <= 1 - (KPMH_Settings::ACTOR_BREATH_SELECTION_SET[1] / 100.0) @breath_increasing = true end end end end @face_sprites.each_index do |i| x = @cell_size * i + self.x + 16 - self.ox + 2 y = KPMH_Settings::CURSOR[0] + self.y + 16 - self.oy + 2 if i == @index w = @face_sprites[@index].bitmap.width h = @face_sprites[@index].bitmap.height zx = @face_sprites[@index].zoom_x zy = @face_sprites[@index].zoom_y @face_sprites[@index].x = x + (w - (w * zx)) / 2 @face_sprites[@index].y = y + (h - (h * zy)) / 2 next end @face_sprites[i].zoom_x = 1 @face_sprites[i].zoom_y = 1 @face_sprites[i].x = x @face_sprites[i].y = y end end end #-------------------------------------------------------------------------- # Atualização #-------------------------------------------------------------------------- def refresh self.contents.clear @item_max = $game_party.members.size create_contents if !@face_sprites.empty? @face_sprites.each{|i| i.dispose} @face_sprites = [] end i = -1 # Define @fw (face width: largura da face) para organização for actor in $game_party.members i += 1 @face_sprites << Sprite.new @face_sprites[i].visible = false @face_sprites[i].z = self.z + 1 # Exibição dos nomes dos personagens self.contents.font.color = system_color self.contents.font.name = KPMH_Settings::MENU_FONT unless KPMH_Settings::HIDDEN_NAME self.contents.draw_text(actor.index * @cell_size, 0, @cell_size - 8, WLH, actor.name, 1) end # Definição do posicionamento primário dos sprites x = @cell_size * actor.index y = KPMH_Settings::CURSOR[0] @face_sprites[i].x = x + self.x + 16 - self.ox + 2 @face_sprites[i].y = y + self.y + 16 - self.oy + 2 if @face_sprites[i].x >= self.x + 16 && @face_sprites[i].x <= self.x + self.width - 16 @face_sprites[i].visible = true end @face_sprites[i].bitmap = Bitmap.new(@cell_size - 8 - 4, KPMH_Settings::CURSOR[1] - 4) # Exibição dos arquivos de faces dos personagens if KPMH_Settings::STATUS_WINDOW_MODE == 0 || KPMH_Settings::STATUS_WINDOW_MODE == 2 x = (@cell_size - [@cell_size, 96].min) / 2 - 4 y = (KPMH_Settings::CURSOR[1] - [@cell_size - 8, 96].min) / 2 - 2 @face_sprites[i].bitmap.draw_face(actor.face_name, actor.face_index, x, y, [@cell_size - 8, 96].min) end # Exibição dos gráficos dos personagens if KPMH_Settings::STATUS_WINDOW_MODE == 1 @face_sprites[i].bitmap.draw_character(actor.character_name, actor.character_index, @face_sprites[i].bitmap.width / 2, @face_sprites[i].bitmap.height / 2 + 16) end if KPMH_Settings::STATUS_WINDOW_MODE == 2 @face_sprites[i].bitmap.draw_character(actor.character_name, actor.character_index, x + 18, y - 2 + [@cell_size - 8, 96].min) end # Exibição das imagens dos personagens if KPMH_Settings::STATUS_WINDOW_MODE == 3 if KPMH_Settings::STATUS_WINDOW_IMAGES.has_key?(actor.id) b = Cache.picture(KPMH_Settings::STATUS_WINDOW_IMAGES[actor.id]) w = @cell_size - 8 h = KPMH_Settings::CURSOR[1] - 4 @face_sprites[i].bitmap.blt(0, 0, b, Rect.new((b.width - w) / 2, (b.height - h) / 2, w, h)) end end # Exibição das classes dos personagens self.contents.font.color = normal_color unless KPMH_Settings::HIDDEN_CLASS self.contents.draw_text(actor.index * @cell_size, 96 + WLH, @cell_size - 8, WLH, actor.class.name, 1) end # Exibição do estado físico dos personagens unless KPMH_Settings::HIDDEN_STATE draw_actor_state(actor, actor.index * @cell_size, WLH * 2 + 96, @cell_size - 8) end # Exibição da nível dos personagens unless KPMH_Settings::HIDDEN_EXP draw_actor_exp(actor, actor.index * @cell_size, WLH * 3 + 96, @cell_size - 8) end # Exibição do HP dos personagens unless KPMH_Settings::HIDDEN_HP draw_actor_hp(actor, actor.index * @cell_size, WLH * 5 + 96, @cell_size - 8) end # Exibição do MP dos personagens unless KPMH_Settings::HIDDEN_MP draw_actor_mp(actor, actor.index * @cell_size, WLH * 6 + 96, @cell_size - 8) end end end #-------------------------------------------------------------------------- # Mover cursor para baixo # wrap : permissão de wrap #-------------------------------------------------------------------------- def cursor_down(wrap = false) end #-------------------------------------------------------------------------- # Mover cursor para cima # wrap : permissão de wrap #-------------------------------------------------------------------------- def cursor_up(wrap = false) end #-------------------------------------------------------------------------- # Mover cursor para direita # wrap : permissão de wrap #-------------------------------------------------------------------------- def cursor_right(wrap = false) if (@index < @item_max - 1 or (wrap and page_row_max == 1)) @index = (@index + 1) % @item_max end end #-------------------------------------------------------------------------- # Mover cursor para esquerda # wrap : permissão de wrap #-------------------------------------------------------------------------- def cursor_left(wrap = false) if (@index > 0 or (wrap and page_row_max == 1)) @index = (@index - 1 + @item_max) % @item_max end end #-------------------------------------------------------------------------- # Volta uma página com o cursor #-------------------------------------------------------------------------- def cursor_pagedown @index = [@index + page_item_max, @item_max - 1].min end #-------------------------------------------------------------------------- # Avança uma página com o cursor #-------------------------------------------------------------------------- def cursor_pageup @index = [@index - page_item_max, 0].max end #-------------------------------------------------------------------------- # Atualização do cursor #-------------------------------------------------------------------------- def update_cursor index = @index - @index_increment y = KPMH_Settings::CURSOR[0] h = KPMH_Settings::CURSOR[1] if !self.active # Sem cursor self.cursor_rect.empty elsif index < @item_max # Padrão self.cursor_rect.set(index * @cell_size, y, @cell_size - 8, h) elsif index >= 100 # Si self.cursor_rect.set((index - 100) * @cell_size, y, @cell_size - 8, h) else # O todo self.cursor_rect.set(0, y, @item_max * @cell_size, h) end end end #============================================================================== # Window_MenuGold #------------------------------------------------------------------------------ # Janela responsável pela exibição do dinheiro no menu. #============================================================================== class Window_MenuGold < Window_Base #-------------------------------------------------------------------------- # Inicialização do objeto # x : Coordenada X da janela # y : Coordenada Y da janela # width : Largura da janela # height : Altura da janela #-------------------------------------------------------------------------- def initialize(x, y, width, height) super(x, y, width, height) if !KPMH_Settings::GOLD_WINDOW[7].nil? && File.exist?("./Graphics/System/#{KPMH_Settings::GOLD_WINDOW[7]}.png") self.windowskin = Cache.system(KPMH_Settings::GOLD_WINDOW[7]) end self.opacity = KPMH_Settings::GOLD_WINDOW[4] self.visible = KPMH_Settings::GOLD_WINDOW[6] refresh end #-------------------------------------------------------------------------- # Atualização #-------------------------------------------------------------------------- def refresh self.contents.clear self.contents.font.name = KPMH_Settings::MENU_FONT draw_icon(KPMH_Settings::GOLD_WINDOW[5], 0, 0) draw_currency_value($game_party.gold, 0, 0, contents.width) end end #============================================================================== # Window_Steps #------------------------------------------------------------------------------ # Janela responsável pela exibição dos passos. #============================================================================== class Window_Steps < Window_Base #-------------------------------------------------------------------------- # Inicialização do objeto # x : Coordenada X da janela # y : Coordenada Y da janela # width : Largura da janela # height : Altura da janela #-------------------------------------------------------------------------- def initialize(x, y, width, height) super(x, y, width, height) if !KPMH_Settings::STEPS_WINDOW[7].nil? && File.exist?("./Graphics/System/#{KPMH_Settings::STEPS_WINDOW[7]}.png") self.windowskin = Cache.system(KPMH_Settings::STEPS_WINDOW[7]) end self.opacity = KPMH_Settings::STEPS_WINDOW[4] self.visible = KPMH_Settings::STEPS_WINDOW[6] refresh end #-------------------------------------------------------------------------- # Atualização #-------------------------------------------------------------------------- def refresh self.contents.clear draw_icon(KPMH_Settings::STEPS_WINDOW[5], 0, 0) self.contents.font.name = KPMH_Settings::MENU_FONT draw_currency_steps_value($game_party.steps, 0, 0, contents.width) end end #============================================================================== # Window_PlayTime #------------------------------------------------------------------------------ # Janela responsável pela exibição do tempo de jogo. #============================================================================== class Window_PlayTime < Window_Base #-------------------------------------------------------------------------- # Inicialização do objeto # x : Coordenada X da janela # y : Coordenada Y da janela # width : Largura da janela # height : Altura da janela #-------------------------------------------------------------------------- def initialize(x, y, width, height) super(x, y, width, height) if !KPMH_Settings::TIME_WINDOW[7].nil? && File.exist?("./Graphics/System/#{KPMH_Settings::TIME_WINDOW[7]}.png") self.windowskin = Cache.system(KPMH_Settings::TIME_WINDOW[7]) end self.opacity = KPMH_Settings::TIME_WINDOW[4] self.visible = KPMH_Settings::TIME_WINDOW[6] 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 = KPMH_Settings::MENU_FONT draw_icon(KPMH_Settings::TIME_WINDOW[5], 0, 0) self.contents.draw_text(0, 0, contents.width, WLH, text, 2) end #-------------------------------------------------------------------------- # Atualização da tela #-------------------------------------------------------------------------- def update super if Graphics.frame_count / Graphics.frame_rate != @total_sec refresh end end end #============================================================================== # Scene_Map #------------------------------------------------------------------------------ # Classe das operações nos mapas. #============================================================================== class Scene_Map < Scene_Base #-------------------------------------------------------------------------- # Alias da tela de menu #-------------------------------------------------------------------------- alias kphm0001_call_menu call_menu #-------------------------------------------------------------------------- # Tela de menu #-------------------------------------------------------------------------- def call_menu $game_temp.map_bgm = RPG::BGM.last $game_temp.map_bgs = RPG::BGS.last RPG::BGM.stop RPG::BGS.stop kphm0001_call_menu end end #============================================================================== # Scene_Menu #------------------------------------------------------------------------------ # Classe de operações na tela do menu. #============================================================================== class Scene_Menu < Scene_Base #-------------------------------------------------------------------------- # Inclusão das constantes e métodos do módulo KPMH_Settings #-------------------------------------------------------------------------- include KPMH_Settings #-------------------------------------------------------------------------- # Alias da inicialização do processo #-------------------------------------------------------------------------- alias kpnhm0001_start start #-------------------------------------------------------------------------- # Inicialização do processo #-------------------------------------------------------------------------- def start if MAIN_MENU super Audio.bgm_play("./Audio/BGM/" + MENU_BGM) create_menu_background create_command_window @mapname_window = Window_MapName.new(MAPNAME_WINDOW[0], MAPNAME_WINDOW[1], MAPNAME_WINDOW[2], MAPNAME_WINDOW[3]) @status_window = Window_HMS.new(STATUS_WINDOW[0], STATUS_WINDOW[1], STATUS_WINDOW[2], STATUS_WINDOW[3]) @gold_window = Window_MenuGold.new(GOLD_WINDOW[0], GOLD_WINDOW[1], GOLD_WINDOW[2], GOLD_WINDOW[3]) @steps_window = Window_Steps.new(STEPS_WINDOW[0], STEPS_WINDOW[1], STEPS_WINDOW[2], STEPS_WINDOW[3]) @playtime_window = Window_PlayTime.new(TIME_WINDOW[0], TIME_WINDOW[1], TIME_WINDOW[2], TIME_WINDOW[3]) else kpnhm0001_start end end #-------------------------------------------------------------------------- # Criação do background do menu #-------------------------------------------------------------------------- def create_menu_background if !MAIN_MENU_BACKGROUND.nil? && !MAIN_MENU_BACKGROUND.empty? && File.exist?("./Graphics/System/#{MAIN_MENU_BACKGROUND}.png") @menuback_sprite = Sprite.new @menuback_sprite.bitmap = Cache.system(MAIN_MENU_BACKGROUND) update_menu_background else super end end #-------------------------------------------------------------------------- # Alias do fim do processo #-------------------------------------------------------------------------- alias kpnhm0001_terminate terminate #-------------------------------------------------------------------------- # Fim do processo #-------------------------------------------------------------------------- def terminate if MAIN_MENU super dispose_menu_background @command_window.dispose @mapname_window.dispose @status_window.dispose @gold_window.dispose @steps_window.dispose @playtime_window.dispose $game_temp.map_bgm.play $game_temp.map_bgs.play else kpnhm0001_terminate end end #-------------------------------------------------------------------------- # Alias da atualização da tela #-------------------------------------------------------------------------- alias kpnhm0001_update update #-------------------------------------------------------------------------- # Atualização da tela #-------------------------------------------------------------------------- def update if MAIN_MENU 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 else kpnhm0001_update end end #-------------------------------------------------------------------------- # Alias da criação da janela de comandos #-------------------------------------------------------------------------- alias kpnhm0001_create_command_window create_command_window #-------------------------------------------------------------------------- # Criação da janela de comandos #-------------------------------------------------------------------------- def create_command_window if MAIN_MENU @command_window = Window_HMC.new(COMMAND_WINDOW[0], COMMAND_WINDOW[1], COMMAND_WINDOW[2], COMMAND_WINDOW[3]) @command_window.index = @menu_index COMMANDS_FUNCTION.each do |key, value| next if COMMANDS_FUNCTION[key][1].nil? && COMMANDS_FUNCTION[key][1].empty? if eval(COMMANDS_FUNCTION[key][1]) == false @command_window.draw_item(key, false) end end else kpnhm0001_create_command_window end end #-------------------------------------------------------------------------- # Atualização da escolha de comando #-------------------------------------------------------------------------- alias kpnhm0001_update_command_selection update_command_selection #-------------------------------------------------------------------------- # Atualização da escolha de comando #-------------------------------------------------------------------------- def update_command_selection if MAIN_MENU if Input.trigger?(Input::B) Audio.se_play("Audio/SE/" + COMMAND_CANCEL) $scene = Scene_Map.new elsif Input.trigger?(Input::C) if COMMANDS_FUNCTION[@command_window.index].nil? Audio.se_play("Audio/SE/" + ERROR_SOUND) return end if !COMMANDS_FUNCTION[@command_window.index][1].nil? && !COMMANDS_FUNCTION[@command_window.index][1].empty? if eval(COMMANDS_FUNCTION[@command_window.index][1]) Audio.se_play("Audio/SE/" + COMMAND_DECISION) eval(COMMANDS_FUNCTION[@command_window.index][0]) else Audio.se_play("Audio/SE/" + ERROR_SOUND) return end else if !COMMANDS_FUNCTION[@command_window.index][0].nil? && !COMMANDS_FUNCTION[@command_window.index][0].empty? Audio.se_play("Audio/SE/" + COMMAND_DECISION) eval(COMMANDS_FUNCTION[@command_window.index][0]) end end end else kpnhm0001_update_command_selection end end #-------------------------------------------------------------------------- # Alias da atualização da seleção de herói #-------------------------------------------------------------------------- alias kpnhm0001_update_actor_selection update_actor_selection #-------------------------------------------------------------------------- # Atualização da seleção de herói #-------------------------------------------------------------------------- def update_actor_selection if MAIN_MENU if Input.trigger?(Input::B) Audio.se_play("Audio/SE/" + ACTOR_CANCEL) end_actor_selection elsif Input.trigger?(Input::C) if ACTORS_FUNCTION[@command_window.index].nil? || ACTORS_FUNCTION[@command_window.index].empty? Audio.se_play("Audio/SE/" + ERROR_SOUND) return end $game_party.last_actor_index = @status_window.index Audio.se_play("Audio/SE/" + ACTOR_DECISION) eval(ACTORS_FUNCTION[@command_window.index]) if ACTOR_FLASH_SELECTION t = ACTOR_FLASH_SELECTION_SET[0] d = ACTOR_FLASH_SELECTION_SET[1] s = @status_window.face_sprites[@status_window.index] s.flash(t, d) loop do Graphics.update s.update d -= 1 break if d == 0 end end end else kpnhm0001_update_actor_selection end end end #============================================================================== # Window_Status #------------------------------------------------------------------------------ # Janela que exibe os status dos personagens. #============================================================================== class Window_Status < Window_Base #-------------------------------------------------------------------------- # Inclusão das constantes e métodos do módulo KPMH_Settings #-------------------------------------------------------------------------- include KPMH_Settings #-------------------------------------------------------------------------- # Alias da atualização #-------------------------------------------------------------------------- alias kpnmh0001_refresh refresh #-------------------------------------------------------------------------- # Atualização #-------------------------------------------------------------------------- def refresh if STATUS_MENU 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(0, 0) # Exibição dos parâmetros do herói draw_parameters(0, 0) # Exibição do equipamento do herói draw_equipments(0, 0) # Exibição de informações adicionais draw_extra else kpnmh0001_refresh end 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 * WLH)) # 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, WLH, @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 = MENU_FONT self.contents.font.color = system_color self.contents.draw_text(0, 0, @fw, WLH, @actor.name, 1) # Exibição dos arquivos de faces dos personagens if STATUS_MENU_WINDOW_MODE == 0 || STATUS_MENU_WINDOW_MODE == 2 draw_face(@actor.face_name, @actor.face_index, 16, WLH, 96) end if STATUS_MENU_WINDOW_MODE == 1 draw_character(@actor.character_name, @actor.character_index, 64, WLH + 64) end if STATUS_MENU_WINDOW_MODE == 2 draw_character(@actor.character_name, @actor.character_index, 32, WLH + 94) end if STATUS_MENU_WINDOW_MODE == 3 if KPMH_Settings::STATUS_WINDOW_IMAGES.has_key?(@actor.id) b = Cache.picture(KPMH_Settings::STATUS_WINDOW_IMAGES[@actor.id]) x = 16 y = WLH w = 96 h = 96 self.contents.blt(x, y, b, Rect.new((b.width - w) / 2, (b.height - h) / 2, w, h)) end end # Exibição do nome da classe do herói self.contents.font.color = normal_color self.contents.draw_text(0, 96 + WLH, @fw, WLH, @actor.class.name, 1) end #-------------------------------------------------------------------------- # Alias da exibição de informações básicas #-------------------------------------------------------------------------- alias kpnmh0001_draw_basic_info draw_basic_info #-------------------------------------------------------------------------- # Exibição de informações básicas # x : exibe na coordenada X # y : exibe na coordenada Y #-------------------------------------------------------------------------- def draw_basic_info(x, y) if STATUS_MENU # Cria um retângulo rect = Rect.new(@fw + 32 - 16, 0, Graphics.width - (@fw + 32) - 16, 96 + (2 * WLH)) # 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, WLH, Graphics.width - (@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, Graphics.width - (@fw + 32) - 16, WLH, "Status", 1) self.contents.font.color = normal_color # Exibição da nível dos personagens draw_actor_exp(@actor, @fw + 32, WLH, @fw - 8) # Exibição do HP dos personagens draw_actor_hp(@actor, @fw + 32, WLH * 2, @fw - 8) # Exibição do MP dos personagens draw_actor_mp(@actor, @fw + 32, WLH * 3, @fw - 8) # Exibição do estado físico dos personagens draw_actor_state(@actor, @fw + 32, WLH * 4 + WLH - 1, Graphics.width - (@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 + 56 , WLH, 180, WLH, Vocab::ExpTotal) self.contents.draw_text(2 * @fw + 56, WLH * 3, 180, WLH, s_next) self.contents.font.color = normal_color self.contents.draw_text(2 * @fw + 56, WLH * 2, 180, WLH, s1, 2) self.contents.draw_text(2 * @fw + 56, WLH * 4, 180, WLH, s2, 2) else kpnmh0001_draw_basic_info(x, y) end end #-------------------------------------------------------------------------- # Alias da exibição dos parâmetros #-------------------------------------------------------------------------- alias kpnmh0001_draw_parameters draw_parameters #-------------------------------------------------------------------------- # Exibição dos parâmetros # x : exibe na coordenada X # y : exibe na coordenada Y #-------------------------------------------------------------------------- def draw_parameters(x, y) if STATUS_MENU # Cria um retângulo rect = Rect.new(0, 96 + (2 * WLH) + 16, Graphics.width / 2 - 24, Graphics.height - (96 + (2 * WLH)) - 48) # 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 * WLH) + 16, Graphics.width / 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 * WLH) + 16, Graphics.width / 2 - 24, WLH, "Parâmetros", 1) self.contents.font.color = normal_color # Exibição dos parâmetros dos personagens draw_actor_parameter(@actor, 44, 96 + (2 * WLH) + 16 + (WLH * 1), 0) draw_actor_parameter(@actor, 44, 96 + (2 * WLH) + 16 + (WLH * 2), 1) draw_actor_parameter(@actor, 44, 96 + (2 * WLH) + 16 + (WLH * 3), 2) draw_actor_parameter(@actor, 44, 96 + (2 * WLH) + 16 + (WLH * 4), 3) draw_actor_parameter(@actor, 44, 96 + (2 * WLH) + 16 + (WLH * 5), 4) draw_actor_parameter(@actor, 44, 96 + (2 * WLH) + 16 + (WLH * 6), 5) draw_actor_parameter(@actor, 44, 96 + (2 * WLH) + 16 + (WLH * 7), 6) draw_actor_parameter(@actor, 44, 96 + (2 * WLH) + 16 + (WLH * 8), 7) else kpnmh0001_draw_parameters(x, y) end end #-------------------------------------------------------------------------- # Alias da exibição dos equipamentos #-------------------------------------------------------------------------- alias kpnmh0001_draw_equipments draw_equipments #-------------------------------------------------------------------------- # Exibição dos equipamentos # x : exibe na coordenada X # y : exibe na coordenada Y #-------------------------------------------------------------------------- def draw_equipments(x, y) if STATUS_MENU # Cria um retângulo rect = Rect.new(Graphics.width / 2 - 8, 96 + (2 * WLH) + 16, Graphics.width / 2 - 24, Graphics.height - (96 + (5 * WLH)) - 48) # 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(Graphics.width / 2 - 8, 96 + (3 * WLH) + 16, Graphics.width / 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(Graphics.width / 2 - 8, 96 + (2 * WLH) + 16, Graphics.width / 2 - 24, WLH, Vocab::equip, 1) # Exibição dos nomes dos tipos de equipamentos if @actor.two_swords_style # Se for estilo duas armas self.contents.draw_text(Graphics.width / 2 - 8 + 16, 96 + (3 * WLH) + 16, Graphics.width / 2 - 24 - 172, WLH, Vocab::weapon1 + ":") self.contents.draw_text(Graphics.width / 2 - 8 + 16, 96 + (4 * WLH) + 16, Graphics.width / 2 - 24 - 172, WLH, Vocab::weapon2 + ":") self.contents.draw_text(Graphics.width / 2 - 8 + 16, 96 + (5 * WLH) + 16, Graphics.width / 2 - 24 - 172, WLH, Vocab::armor2 + ":") self.contents.draw_text(Graphics.width / 2 - 8 + 16, 96 + (6 * WLH) + 16, Graphics.width / 2 - 24 - 172, WLH, Vocab::armor3 + ":") self.contents.draw_text(Graphics.width / 2 - 8 + 16, 96 + (7 * WLH) + 16, Graphics.width / 2 - 24 - 172, WLH, Vocab::armor4 + ":") else # Se não for estilo duas espadas (padrão) self.contents.draw_text(Graphics.width / 2 - 8 + 16, 96 + (3 * WLH) + 16, Graphics.width / 2 - 24 - 172, WLH, Vocab::weapon + ":") self.contents.draw_text(Graphics.width / 2 - 8 + 16, 96 + (4 * WLH) + 16, Graphics.width / 2 - 24 - 172, WLH, Vocab::armor1 + ":") self.contents.draw_text(Graphics.width / 2 - 8 + 16, 96 + (5 * WLH) + 16, Graphics.width / 2 - 24 - 172, WLH, Vocab::armor2 + ":") self.contents.draw_text(Graphics.width / 2 - 8 + 16, 96 + (6 * WLH) + 16, Graphics.width / 2 - 24 - 172, WLH, Vocab::armor3 + ":") self.contents.draw_text(Graphics.width / 2 - 8 + 16, 96 + (7 * WLH) + 16, Graphics.width / 2 - 24 - 172, WLH, Vocab::armor4 + ":") end # Exibição dos equipamentos do herói for i in 0..4 draw_item_name(@actor.equips[i], Graphics.width - 172 - 16, (96 + (2 * WLH) + 16) + WLH * (i + 1)) end else kpnmh0001_draw_equipments(x, y) end end #-------------------------------------------------------------------------- # Exibição das informações adicional #-------------------------------------------------------------------------- def draw_extra # Cria um retângulo rect = Rect.new(Graphics.width / 2 - 8, 2 * (96 + (2 * WLH) + 20), Graphics.width / 2 - 24, Graphics.height - (2 * (96 + (5 * WLH) - 36))) # 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(Graphics.width / 2 - 8, 2 * (96 + (2 * WLH) + 20) + WLH, Graphics.width / 2 - 24, 2) # Preenche o retângulo self.contents.fill_rect(rect, system_color) self.contents.font.color = system_color self.contents.draw_text(Graphics.width / 2 - 8, 2 * (96 + (2 * WLH) + 20), Graphics.width / 2 - 24, WLH, "Pressione", 1) self.contents.draw_text(Graphics.width / 2 - 8, 2 * (96 + (2 * WLH) + 20) + WLH + 4, Graphics.width / 2 - 24, WLH, "← Anterior | Próximo →", 1) 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(actor, x, y, type) case type when 0 parameter_name = Vocab::atk parameter_value = actor.atk when 1 parameter_name = Vocab::def parameter_value = actor.def when 2 parameter_name = Vocab::spi parameter_value = actor.spi when 3 parameter_name = Vocab::agi parameter_value = actor.agi when 4 parameter_name = Vocab::hit parameter_value = actor.hit when 5 parameter_name = Vocab::eva parameter_value = actor.eva when 6 parameter_name = Vocab::cri parameter_value = actor.cri when 7 parameter_name = Vocab::odds parameter_value = actor.odds end self.contents.font.color = system_color self.contents.draw_text(x, y, 120, WLH, parameter_name) self.contents.font.color = normal_color self.contents.draw_text(x + 120, y, 36, WLH, parameter_value, 2) end end #============================================================================== # Scene_Status #------------------------------------------------------------------------------ # Classe de operações na tela de status. #============================================================================== class Scene_Status < Scene_Base #-------------------------------------------------------------------------- # Inclusão das constantes e métodos do módulo KPMH_Settings #-------------------------------------------------------------------------- include KPMH_Settings #-------------------------------------------------------------------------- # Alias da inicialização do processo #-------------------------------------------------------------------------- alias kpmnh0001_start start #-------------------------------------------------------------------------- # Inicialização do processo #-------------------------------------------------------------------------- def start if KPMH_Settings::STATUS_MENU super create_menu_background @actor = $game_party.members[@actor_index] @status_window = Window_Status.new(@actor) @status_window.x = KPMH_Settings::STATUS_MWINDOW[0] @status_window.y = KPMH_Settings::STATUS_MWINDOW[1] @status_window.width = KPMH_Settings::STATUS_MWINDOW[2] @status_window.height = KPMH_Settings::STATUS_MWINDOW[3] @status_window.opacity = KPMH_Settings::STATUS_MWINDOW[4] if !KPMH_Settings::TIME_WINDOW[7].nil? && File.exist?("./Graphics/System/#{KPMH_Settings::STATUS_MWINDOW[5]}.png") @status_window.windowskin = Cache.system(KPMH_Settings::STATUS_MWINDOW[5]) end else kpmnh0001_start end end #-------------------------------------------------------------------------- # Criação do background do menu #-------------------------------------------------------------------------- def create_menu_background if !STATUS_MENU_BACKGROUND.nil? && !STATUS_MENU_BACKGROUND.empty? && File.exist?("./Graphics/System/#{STATUS_MENU_BACKGROUND}.png") @menuback_sprite = Sprite.new @menuback_sprite.bitmap = Cache.system(!TATUS_MENU_BACKGROUND) update_menu_background else super end end #-------------------------------------------------------------------------- # Alias da atualização #-------------------------------------------------------------------------- alias kpmnh0001_update update #-------------------------------------------------------------------------- # Atualização #-------------------------------------------------------------------------- def update if KPMH_Settings::STATUS_MENU update_menu_background @status_window.update if Input.trigger?(Input::B) Sound.play_cancel return_scene elsif Input.trigger?(Input::R) Sound.play_cursor next_actor elsif Input.trigger?(Input::L) Sound.play_cursor prev_actor elsif Input.trigger?(Input::RIGHT) Sound.play_cursor next_actor elsif Input.trigger?(Input::LEFT) Sound.play_cursor prev_actor end super else kpmnh0001_update end end end