Início
Portal
Registrar
EntrarFleX Menu 1.0.1.1
3 participantes
Página 1 de 1
FleX Menu 1.0.1.1
por natan Seg Out 26 2009, 19:13
Menu bem legal
Creditos ao autor: Bruno Augusto
Creditos ao autor: Bruno Augusto
- Código:
#=========================================================
# ** FleX Menu 1.0.1.1 para RMXP
# ========================================================
# (c) 2009 - Imaggens Studio
# --------------------------------------------------------
# > Autor: Bruno Augusto
# --------------------------------------------------------
# > FleX Menu
# > Menu customizável e flexível que substitui o do RMXP
#
# > Iniciado em: Sábado, 21 de Março de 2009
# > Atualizado em: Sábado, 4 de Abril de 2009
#
# > Lançamento: Segunda-Feira, 23 de Março de 2009
# > Re-Publicação: Domingo, 5 de Abril de 2009
#=========================================================
=begin
+---------------------------------------------------------------
| ** FleX Menu 1.0.1.1: Recursos & Atualizações
| ==============================================================
| - [UPDATE] Ajuste na visibilidade da dummy window quando todas
| as 3 partes do menu lateral (com exceção do menu principal)
| estão visíveis.
| Juntamente com esse ajuste houve redimensionamento destas
| três janelas, para completar o espaço deixado pela "micro"
| dummy window visualmente desnecessária
| - [UPDATE] Corrigidas as cores padrão para as barras de SP e XP
| quando as existentes nas configurações diferirem as
| quantidades de índices de 4 (formato array RGB + alpha)
| ou 2 (formatoHexadecimal + alpha)
| O motivo da atualização é que as duas barras citadas
| estavam com as mesmas cores que a de HP (alaranjado)
| - [NOVO] Adicionando método get_gradient_colors() que, através
| de um parâmetro string determina, internamente, qual esquema
| de cores será utilizado para as barras (HP, SP, XP)
| Assim, reduz-se a quantidade de código em torno de 72 linhas,
| sem contar os espaços estruturadores e comentários, e torna
| o código mais fácil de se ler e atualizar, se necessário
+---------------------------------------------------------------
| ** FleX Menu 1.0.1: Recursos & Atualizações
| ==============================================================
| - [NOVO] Configurações empacotadas em módulo, garantindo
| compatibilidade entre diferentes scripts
| - [NOVO] Retorno do item de menu "Status"
| - [NOVO] "Registro" do script na variável global $imaggens
| - [UPDATE]Correção na segunda cor para formação do gradiente
| da barra de SP (estava amarelo)
| - [UPDATE] Alteração na largura da porção do Menu referente ao
| Nome do Mapa quando TODOS os itens extra do Menu lateral
| estão presentes.
+---------------------------------------------------------------
| ** FleX Menu 1.0: Recursos
| ==============================================================
| - Personalização dos textos do menu sem interferir
| no vocabulário do sistema do jogo
| - Controle de Exibição das janelas que serão mostradas
| no menu: Tempo de Jogo, Passos, Ouro e Nome do Mapa
| - Uso ou não uso de uma Dummy_Window vertical que preenche
| a porção da tela que fica vazia quando se oculta uma
| ou mais janelas de informação
| - Ocultar automaticamente a janela com o Nome do Mapa
| quando o próprio contiver uma tag (personalizável)
| definida na constante MAP_EXCLUDE_TAG
| - Remover automaticamente palavras que não devem fazer parte
| do nome do mapa. Útil quando scripts terceirizados
| obrigam a inclusão de tags proprietárias no nome do mapa
| - Posicionamento personalizado do Menu Principal:
| Esquerda ou à Direita
| - Posicionamento personalizado da janela com o Nome do Mapa:
| Acima ou Abaixo
| - Personalização da ordem em que as janelas informativas do
| menu lateral serão exibidas. Basta alterar a ordem das
| letras na matriz
| - Exibição ou não do status do jogador cercado por colchete,
| como no estilo padrão do menu do RMXP (ex: [ Confuso ])
| - Exibição animada dos charsets dos personagens, simulando
| caminhada
| - Extra na movimentação do charset dos personagens
| (implica TRUE na configuração acima): Girar 360º equanto
| estiver em movimento
| - Extra na movimentação 360º do charset dos personagens:
| Definição do sentido do giro: horário ou anti-horário
| - Customização das cores que compõem o gradiente (dégradè)
| das barras de HP, MP (ou SP) e XP
| - Extra na customização das cores: Uso de canais RGB ou
| valores hexadecimais
| - Extra na exibição das barras: Exibição ou não da quantidade
| de cada "elemento" seguido do total possível (ex: 100/200)
+---------------------------------------------------------------
=end
module FleX
# Textos do Menu
MENU_ITEMS = [ 'Itens',
'Habilidades',
'Equipamento',
'Status',
'Salvar',
'Sair'
]
# Textos das janelas do Menu Lateral
STEPS_LABEL = 'Passos'
GOLD_LABEL = 'Ouro'
MAP_LABEL = 'Local:'
# Textos Complementares e das Barras de Informação
LEVEL_LABEL = 'N'
LIVE_LABEL = 'Vivo'
XP_LABEL = 'XP'
HP_LABEL = 'HP'
MP_LABEL = 'MP'
NO_HP = 'Sem HP'
NO_MP = 'Sem MP'
LOW_HP = 'Fraco'
# Exibição das Janelas no Menu Lateral
SHOW_TIME = true
SHOW_STEPS = true
SHOW_GOLD = true
SHOW_MAP = true
# Habilitar Dummy_Window?
USE_DUMMY = true
# Mapas contendo a seguinte tag não terão
# a janela com o Nome do Mapa no menu
MAP_EXCLUDE_TAG = '[EXCLUDE]'
# As palavras que estiverem nesta lista
#(separadas por vírgulas) serão removidas
# do Nome do Mapa
MAP_EXCLUDE_WORDS = []
# Posicionamentos: Menu, Nome do Mapa e Ordenação
MENU_SIDE = 1 # 1 = Direita / 2 = Esquerda
MAP_SIDE = 1 # 0 = Superior / 1 = Inferior
POSITION = [ 'M', 'T', 'S', 'G' ]
# Extra Visual
USE_STATE_BRACKETS = false # Coloca o status do personagem
# [ entre colchetes ]
BARS_IN_NOS = true
# Animação dos Charsets
ANIMATE_CHAR = true # Habilita animação
ANIMATE_360 = true # Habilita animação 360º
ROTATE_TO = 'right' # Personaliza o sentido do giro
# Cores do Gradiente
#===========================================================
# ** Padrão RGB + Alpha
# Cada matriz com 4 índices de 0 à 255 cada
#
# ** Padrão Hexadecimal + Alpha:
# Cada matriz com 2 índices, sendo o primeiro uma string
# e o segundo o canal alpha, de 0 à 255
#
# ** Se a matriz possuir elementos sobrando ou faltando
# a cor utilizada será as mesmas pré-configuradas
# porém internamente ao código
#===========================================================
HP_GRADIENT_COLOR_1 = [ 233, 127, 63, 255 ]
HP_GRADIENT_COLOR_2 = [ 238, 190, 63, 255 ]
SP_GRADIENT_COLOR_1 = [ 63, 127, 191, 255 ]
SP_GRADIENT_COLOR_2 = [ 63, 191, 239, 255 ]
XP_GRADIENT_COLOR_1 = [ 63, 127, 0, 255 ]
XP_GRADIENT_COLOR_2 = [ 63, 197, 0, 255 ]
end
#=================# FIM DAS CONFIGURAÇÕES #=====================#
$imaggens = {} if $imaggens == nil
$imaggens['FleX'] = true
#==========================================================
# ** FleX_Menu
# ---------------------------------------------------------
# > Classe construtora do menu
#==========================================================
class Scene_Menu
def initialize( index = 0 )
@index = index
@dummy_height = 0 # Altura da Janela Vazia Complementar
$mapname_exists = true
# Todas as janelas estão sendo exibidas?
if FleX::SHOW_TIME == true and FleX::SHOW_STEPS == true and
FleX::SHOW_GOLD == true
$all_windows = true
else
$all_windows = false
end
end
def main
# Menu Principal
@command = Window_Command.new( 160, FleX::MENU_ITEMS )
@command.index = @index
@command.x = FleX::MENU_SIDE == 1 ? 480 : 0
# Passos Dados
@steps = Window_Common.new( 160, 75, 'steps' )
@steps.x = FleX::MENU_SIDE == 1 ? 480 : 0
# Tempo de Jogo
@playtime = Window_Common.new( 160, 74, 'playtime' )
@playtime.x = FleX::MENU_SIDE == 1 ? 480 : 0
# Ouro Acumulado
@gold = Window_Common.new( 160, 75, 'gold' )
@gold.x = FleX::MENU_SIDE == 1 ? 480 : 0
# Visibilidade da Janela com o Nome do Mapa
if $game_map.name.include?( FleX::MAP_EXCLUDE_TAG ) or
FleX::SHOW_MAP == false
$mapname_exists = false # Flag Global de Existência do Mapa
# Janela Principal
@players = Window_PlayerData.new( 480, 480 )
@dummy_height += 33
else
# Nome do Mapa
if $all_windows == true
map_width = 640 - @command.width
@dummy_height += FleX::USE_DUMMY == true ? 33 : 0
else
map_width = 640
@dummy_height -= 32
end
@map = Window_Common.new( map_width, 64, 'map' )
@map.y = FleX::MAP_SIDE == 0 ? 0 : 416
# Janela Principal
@players = Window_PlayerData.new( 480, 416 )
end
# Posicionamento da Janela Principal
@players.x = FleX::MENU_SIDE == 1 ? 0 : @command.width
@players.y = FleX::MAP_SIDE == 0 ? 64 : 0
# Redimensionando e reposicionando as janelas do menu lateral
if $all_windows == true
@playtime.height += 12
@steps.height += 10
@gold.height += 10
@playtime.y += 0
@steps.y += 12
@gold.y += 22
end
# Posicionamento Vertical dos Elementos Laterais
position = FleX::MAP_SIDE == 0 ? 64 : 0
for i in 0...4
case FleX::POSITION[ i ]
# Menu Principal
when 'M'
@command.y = position
position += @command.height
# Passos Dados
when 'S'
if FleX::SHOW_STEPS == true
@steps.y = position
position += @steps.height
else
@steps.visible = false
@dummy_height += @steps.height
end
# Tempo de Jogo
when 'T'
if FleX::SHOW_TIME == true
@playtime.y = position
position += @playtime.height
else
@playtime.visible = false
@dummy_height += @playtime.height
end
# Ouro Acumulado
when 'G'
if FleX::SHOW_GOLD == true
@gold.y = position
position += @gold.height
else
@gold.visible = false
@dummy_height += @gold.height
end
end
end
# Dummy Window
if @dummy_height != 0
@dummy = Window_Common.new( @command.width,
@dummy_height, 'dummy' )
@dummy.x = FleX::MENU_SIDE == 1 ? 480 : 0
@dummy.y = position
@dummy.visible = FleX::USE_DUMMY == true ? true : false
end
# Sobrescrevendo visibilidade da dummy window
if $all_windows == true
@dummy.visible = false if @dummy != nil
end
#------------------
if $game_party.actors.size == 0
@command.disable_item(0)
@command.disable_item(1)
@command.disable_item(2)
end
if $game_system.save_disabled
@command.disable_item(3)
end
#------------------
Graphics.transition
loop do
Graphics.update # Gráficos
Input.update # Teclas
update # Frames
if $scene != self
break
end
end
Graphics.freeze
#-------------------
@command.dispose
@steps.dispose
@playtime.dispose
@gold.dispose
@map.dispose if $mapname_exists == true
@players.dispose
if @dummy_height != 0
@dummy.dispose
end
end
#==========================================================
# ** update
# ---------------------------------------------------------
# > Atualiza informações das janelas do menu
#==========================================================
def update
@command.update
@steps.update
@playtime.update
@gold.update
@map.update if $mapname_exists == true
@players.update
update_commands
end
#==========================================================
# ** update_commands
# ---------------------------------------------------------
# > Atualiza informações dos comandos do Menu Principal
#==========================================================
def update_commands
# Retornando ao mapa
if Input.trigger?( Input::B )
$scene = Scene_Map.new
return
end
# Ações do Menu
if Input.trigger?( Input::C )
# Impedindo acesso a ações dos Personagens
# quando sem personagens (no grupo de aliados)
if $game_party.actors.size == 0 and
@command.index < 4
return
end
# Direcionando as açõesdo menu
case @command.index
when 0 # Itens
$scene = Scene_Item.new
when 1 # Habilidades
$scene = Scene_Skill.new
when 2 # Equipamentos
$scene = Scene_Equip.new
when 3 # Status
$scene = Scene_Status.new
when 4 # Salvar
$scene = Scene_Save.new
when 5 # Sair
$scene = Scene_End.new
end
return
end
end
end
#==========================================================
# ** Window_Common
# ---------------------------------------------------------
# > Classe responsável por criar diversas janelas
# diferentes cada qual com sua própria largura, altura
# e conteúdo, definido por métodos próprios
#==========================================================
class Window_Common < Window_Base
def initialize( width, height, window )
super( 0, 0, width, height )
@window = window
@extra_y = $all_windows == true ? 4 : 0
self.contents = Bitmap.new( width - 32, height - 32 )
case @window
when 'steps'
steps
when 'playtime'
playtime
when 'gold'
gold
when 'map'
map
when 'dummy'
return
end
end
#==========================================================
# ** steps
# ---------------------------------------------------------
# > Procedimento que exibe a quantidade de passos dados
# pelo jogador
#==========================================================
def steps
self.contents.clear
self.contents.font.color = system_color
self.contents.draw_text( 4, 7 + @extra_y, 120, 32,
FleX::STEPS_LABEL )
self.contents.font.color = normal_color
self.contents.draw_text( 4, 7 + @extra_y, 120, 32,
$game_party.steps.to_s, 2 )
end
#==========================================================
# ** playtime
# ---------------------------------------------------------
# > Procedimento que exibe o tempo de jogo
#==========================================================
def playtime
self.contents.clear
# Calculando o tempo
@time = Graphics.frame_count / Graphics.frame_rate
# Formatando...
hour = @time / 60 / 60 # Horas
minutes = @time / 60 % 60 # Minutos
seconds = @time % 60 # Segundos
text = sprintf( "%02d:%02d:%02d", hour, minutes, seconds )
self.contents.font.color = normal_color
self.contents.draw_text( 4, 10 + @extra_y, 120, 24, text, 1 )
end
#==========================================================
# ** gold
# ---------------------------------------------------------
# > Procedimento que exibe a quantidade de ouro acumulado
#==========================================================
def gold
self.contents.clear
box = contents.text_size( FleX::GOLD_LABEL ).width
self.contents.font.color = system_color
self.contents.draw_text( 4, 7 + @extra_y, 120, 32,
FleX::GOLD_LABEL )
self.contents.font.color = normal_color
self.contents.draw_text( 4, 7 + @extra_y, 120, 32,
$game_party.gold.to_s, 2 )
end
#==========================================================
# ** map
# ---------------------------------------------------------
# > Procedimento que exibe o nome do mapa
#==========================================================
def map
self.contents.clear
label = contents.text_size( FleX::MAP_LABEL ).width
self.contents.font.color = system_color
self.contents.draw_text( 4, 0, label, 32, FleX::MAP_LABEL )
# Removendo expressões não desejadas do nome do mapa
# Ajuda indireta do woratana ^^
mapName = $game_map.name.to_s
if FleX::MAP_EXCLUDE_WORDS.size != 0
FleX::MAP_EXCLUDE_WORDS.each {|i| mapName.gsub!(/#{i}/i) {} }
end
self.contents.font.color = normal_color
self.contents.draw_text( label + 8, 0, 286, 32, mapName )
end
#==========================================================
# ** update
# ---------------------------------------------------------
# > Atualiza informações
# Especificamente, o tempo de jogo decorrido
#==========================================================
def update
super
if @window == 'playtime'
if Graphics.frame_count / Graphics.frame_rate != @time
playtime
end
end
end
end
#==========================================================
# ** Window_PlayerData
# ---------------------------------------------------------
# > Janela que exibe as informações dos jogadores
#==========================================================
class Window_PlayerData < Window_Base
def initialize( width, height )
super( 0, 0, width, height )
self.contents = Bitmap.new( width - 32, height - 32 )
@frame = 0 # Posição Horizontal do Char
@pose = 0 # Posição Vertical do Char
@actor = 0
refresh
end
#==========================================================
# ** refresh
# ---------------------------------------------------------
# > Popula a tela de menu com as informações
#==========================================================
def refresh
self.contents.clear
extra_x = FleX::USE_STATE_BRACKETS == true ?
self.contents.text_size( '[ ]' ).width : 0
extra_y = $mapname_exists == true ? 0 : 32
for i in 0...$game_party.actors.size
x = 64
y = extra_y + i * 96
@actor = $game_party.actors[ i ]
# Gráfico do personagem
draw_actor_sprite( @actor, x - 42, y + 80 )
# Nome do Personagem
draw_actor_name( @actor, x, y + 8 )
# Status
draw_actor_state( @actor, x, y + 36, 120 )
# Nível do Personagem
draw_actor_level( @actor, x, y + 60 )
#--------------------
# Classe do Personagem
draw_actor_class( @actor, x + 128 + extra_x, y - 4 )
# HP do Personagem
draw_actor_hp( @actor, x + 128 + extra_x, y + 30, 196 )
# SP do Perosonagem
draw_actor_sp( @actor, x + 128 + extra_x, y + 54, 196 )
# Experiência do Personagem
draw_actor_xp( @actor, x + 128 + extra_x, y + 78, 196 )
end
end
#==========================================================
# ** update
# ---------------------------------------------------------
# > Atualiza informações
# Especificamente, anima o charset do personagem se
# configurado para isso
#==========================================================
def update
super
# Verifica se a animação foi habilitada
if FleX::ANIMATE_CHAR == true
if Graphics.frame_count % 10 == 0
# Girar o Personagem 360º...
if FleX::ANIMATE_360 == true and @frame == 3
# ... em sentido horário...
if FleX::ROTATE_TO == 'right'
case @pose
when 0; @pose = 1
when 1; @pose = 3
when 3; @pose = 2
when 2; @pose = 0
end
#... ou anti-horário
elsif FleX::ROTATE_TO == 'left'
case @pose
when 0; @pose = 2
when 2; @pose = 3
when 3; @pose = 1
when 1; @pose = 0
end
end
end
# Simular o Personagem andando
@frame == 3 ? @frame = 0 : @frame += 1
# Redesenha o Personagem
refresh
end
end
end
#==========================================================
# ** draw_actor_sprite
# ---------------------------------------------------------
# > Desenha o charset do personagem na tela, animado ou não
#==========================================================
def draw_actor_sprite( actor, x, y )
bitmap = RPG::Cache.character( actor.character_name,
actor.character_hue )
cw = bitmap.width / 4
ch = bitmap.height / 4
if FleX::ANIMATE_CHAR == false
rect = Rect.new( 0, 0, cw, ch )
else
rect = Rect.new( cw * @frame, ch * @pose, cw, ch)
end
self.contents.blt( x - cw / 2, y - ch, bitmap, rect )
end
#==========================================================
# ** draw_actor_state
# ---------------------------------------------------------
# > Sobrescreve o método original de escrever o(s) estado(s)
# do personagem por outromais simplificado
#==========================================================
def draw_actor_state( battler, x, y, width )
text = ''
for i in battler.states
# Aparentemente, no XP apenas o último status é exibido
text = $data_states[ i ].name
end
if FleX::USE_STATE_BRACKETS == true
text = text == '' ? '[ ' + FleX::LIVE_LABEL + ' ]' :
'[ ' + text + ' ]'
width += self.contents.text_size( '[ ]' ).width
else
text = text == '' ? FleX::LIVE_LABEL : text
end
# Escrevendo...
self.contents.font.color = battler.hp == 0 ?
knockout_color : normal_color
self.contents.draw_text( x, y, width, 32, text )
end
#==========================================================
# ** draw_actor_hp
# ---------------------------------------------------------
# > Sobrescreve o método original de escrever o HP do
# personagem por outra mais elaborado, com gradiente
#==========================================================
def draw_actor_hp( actor, x, y, width, height = 12 )
# Cor de Fundo
bg = Color.new( 0, 0, 0, 160 )
# Cores do Gradiente
gcs = get_gradient_colors( 'HP' )
gc1 = gcs[ 0 ]
gc2 = gcs[ 1 ]
#-------------------
# Cáculo do HP
if actor.hp != 0
gw = width * actor.hp / actor.maxhp
else
gw = width * actor.hp + 10
end
self.contents.fill_rect( x + 30, y, width, height, bg )
gradient( x + 31, y + 1, gw - 2, height - 2, gc1, gc2 )
self.contents.font.color = gc1
self.contents.draw_text( x, y - 5, 30, 20, FleX::HP_LABEL )
if FleX::BARS_IN_NOS == true
if actor.hp == 0
content = FleX::NO_HP
elsif actor.hp <= actor.maxhp / 10
content = FleX::LOW_HP
else
content = actor.hp.to_s + '/' + actor.maxhp.to_s
end
content_width = self.contents.text_size( content ).width
self.contents.font.color = normal_color
self.contents.draw_text( width * 2 - content_width + 20, y - 10, content_width, 20, content )
end
end
#==========================================================
# ** draw_actor_sp
# ---------------------------------------------------------
# > Sobrescreve o método original de escrever o SP do
# personagem por outra mais elaborado, com gradiente
#==========================================================
def draw_actor_sp( actor, x, y, width, height =12 )
# Cor de Fundo
bg = Color.new( 0, 0, 0, 160 )
# Cores do Gradiente
gcs = get_gradient_colors( 'SP' )
gc1 = gcs[ 0 ]
gc2 = gcs[ 1 ]
#-------------------
# Calcula o SP
if actor.maxsp != 0
gw = width * actor.sp / actor.maxsp
else
gw = width * actor.sp + 10
end
self.contents.fill_rect( x + 30, y, width, height, bg )
gradient( x + 31, y + 1, gw - 2, height - 2, gc1, gc2 )
self.contents.font.color = gc1
self.contents.draw_text( x, y - 5, 30, 20, FleX::MP_LABEL )
if FleX::BARS_IN_NOS == true
if actor.sp == 0
content = FleX::NO_MP
else
content = actor.sp.to_s + '/' + actor.maxsp.to_s
end
content_width = self.contents.text_size( content ).width
self.contents.font.color = normal_color
self.contents.draw_text( width * 2 - content_width + 20, y - 10, content_width, 20, content )
end
end
#==========================================================
# ** draw_actor_xp
# ---------------------------------------------------------
# > Sobrescreve o método original de escrever o XP do
# personagem por outro mais elaborado, com gradiente
#==========================================================
def draw_actor_xp( actor, x, y, width, height = 12 )
# Cor de Fundo
bg = Color.new( 0, 0, 0, 160 )
# Cores do Gradiente
gcs = get_gradient_colors( 'XP' )
gc1 = gcs[ 0 ]
gc2 = gcs[ 1 ]
#-------------------
# Calcula o XP
if actor.exp != 0
gw = width * actor.exp / actor.next_exp
else
gw = width * actor.exp + 10
end
self.contents.fill_rect( x + 30, y, width, height, bg )
gradient( x + 31, y + 1, gw - 2, height - 2, gc1, gc2 )
self.contents.font.color = gc1
self.contents.draw_text( x, y - 5, 30, 20, FleX::XP_LABEL )
if FleX::BARS_IN_NOS == true
content = actor.exp.to_s + '/' + actor.next_exp.to_s
content_width = self.contents.text_size( content ).width
self.contents.font.color = normal_color
self.contents.draw_text( width * 2 - content_width + 20, y - 10, content_width, 20, content )
end
end
#==========================================================
# ** gradient
# ---------------------------------------------------------
# > Cria uma barra retalgular colorida em gradiente
# crescente de duas cores
#==========================================================
def gradient( x, y, width, height, c1, c2 )
for i in 1..width
x2 = x + i - 1
# Canais RGB e Alpha
r = c1.red * (width - i) / width + c2.red * i / width
g = c1.green * (width - i) / width + c2.green * i / width
b = c1.blue * (width - i) / width + c2.blue * i / width
a = c1.alpha * (width - i) / width + c2.alpha * i / width
self.contents.fill_rect( x2, y, 1, height,
Color.new( r, g, b, a ) )
end
end
#==========================================================
# ** get_hex
# ---------------------------------------------------------
# > Converte uma valor Hexadecimal nos Canais RGB
#==========================================================
def get_hex( n, alpha )
red = 0
green = 0
blue = 0
if n.size != 6
print( "Código de cores Hexadecimais devem ter 6 caracteres de comprimento!\nA cor Normal do sistema será usada" )
return normal_color
end
for i in 1..6
sliced = n.slice!(/./m)
value = hexconvert( sliced )
case i
when 1; red += value * 16
when 2; red += value
when 3; green += value * 16
when 4; green += value
when 5; blue += value * 16
when 6; blue += value
end
end
return Color.new( red, green, blue, alpha )
end
#==========================================================
# ** hexconvert
# ---------------------------------------------------------
# > "Decodifica" cada um dos três pares de uma cor Hexa
#==========================================================
def hexconvert(n)
case n
when "0"; return 0
when "1"; return 1
when "2"; return 2
when "3"; return 3
when "4"; return 4
when "5"; return 5
when "6"; return 6
when "7"; return 7
when "8"; return 8
when "9"; return 9
when "A"; return 10
when "B"; return 11
when "C"; return 12
when "D"; return 13
when "E"; return 14
when "F";return 15
else; return -1
end
end
#==========================================================
# ** get_gradient_colors
# ---------------------------------------------------------
# > Wrapper de codificação para obtenção das cores de
# gradiente para criação das barras de HP, SP e XP
#==========================================================
def get_gradient_colors( schema )
if schema == 'HP'
cs1 = FleX::HP_GRADIENT_COLOR_1
cs2 = FleX::HP_GRADIENT_COLOR_2
cs1_d = [ 233, 127, 63, 255 ]
cs2_d = [ 238, 190, 63, 255 ]
elsif schema == 'SP'
cs1 = FleX::SP_GRADIENT_COLOR_1
cs2 = FleX::SP_GRADIENT_COLOR_2
cs1_d = [ 63, 127, 191, 255 ]
cs2_d = [ 63, 191, 239, 255 ]
elsif schema == 'XP'
cs1 = FleX::XP_GRADIENT_COLOR_1
cs2 = FleX::XP_GRADIENT_COLOR_2
cs1_d = [ 63, 127, 0, 255 ]
cs2_d = [ 63, 197, 0, 255 ]
end
#-------------------
# Primeira Cor
if cs1.size == 4
# Array de cores
gc1 = Color.new( cs1[ 0 ], cs1[ 1 ], cs1[ 2 ], cs1[ 3 ] )
elsif cs1.size == 2
# Hexadecimais
if cs1[ 0 ].sub( /([0123456789ABCDEF]+)/,'' )
gc1 = get_hex( $1, cs1[ 1 ] )
end
else
# Cor Padrão
gc1 = Color.new( cs1_d[ 0 ], cs1_d[ 1 ],
cs1_d[ 2 ], cs1_d[ 3 ] )
end
#------------------
# Segunda Cor
if cs2.size == 4
# Array de Cores
gc2 = Color.new( cs2[ 0 ], cs2[ 1 ], cs2[ 2 ], cs2[ 3 ] )
elsif cs2.size == 2
# Hexadecimais
if cs2[ 0 ].sub( /([0123456789ABCDEF]+)/,'' )
gc2 = get_hex( $1, cs2[ 1 ] )
end
else
# Cor Padrão
gc2 = Color.new( cs2_d[ 0 ], cs2_d[ 1 ],
cs2_d[ 2 ], cs2_d[ 3 ] )
end
# Retornando...
return [ gc1, gc2 ]
end
end
#==========================================================
# ** Game_Map
# ---------------------------------------------------------
# > Classe interpretadora dos mapas do jogo
#==========================================================
class Game_Map
#==========================================================
# ** name
# ---------------------------------------------------------
# > Procedimento que atribui à um índice de variável global
# o ID do mapa em que o personagem principal está
#==========================================================
def name
$MapInfos[ @map_id ]
end
end
class Game_Actor
#==========================================================
# ** exp
# ---------------------------------------------------------
# > Procedimento que retorna um número operável quanto de
# XP o personagem possui ou o (zero) se não tiver nada.
# Diferentemente do original exp_s que além de retornar
# uma string numérica, se o personagem não tiver nada
# retorna 'tracinhos'
#==========================================================
def exp
return @exp_list[ @level +1 ] > 0 ? @exp : 0
end
#==========================================================
# ** next_exp
# ---------------------------------------------------------
# > Exatamente igual ao procedimento anterior, porém o
# valor retornado é a quantidade de XP necessária
# para a evolução
#==========================================================
def next_exp
return @exp_list[ @level + 1 ] > 0 ?
@exp_list[ @level + 1 ]: 0
end
end
#==========================================================
# ** Scene_Tile
# ---------------------------------------------------------
# > Classe interpretadora da janela de título
#==========================================================
class Scene_Title
$MapInfos = load_data("Data/MapInfos.rxdata")
for key in $MapInfos.keys
$MapInfos[ key ] = $MapInfos[ key ].name
end
end
natan- Estudante
- Mensagens : 26
Re: FleX Menu 1.0.1.1
por GrandMaker Dom Abr 24 2011, 16:42
MUIIIITTTTTTTTTO SSSSSSSSSSHHHHHHHHHHOw
+1
+1
GrandMaker- Aluno
- Mensagens : 4
Caio Juan- Admin
- Mensagens : 123
-
Página 1 de 1
Permissões neste sub-fórum
Não podes responder a tópicos