#=========================================================
# ** 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