Aldeia RPG

Gostaria de reagir a esta mensagem? Crie uma conta em poucos cliques ou inicie sessão para continuar.

Suporte no desenvolvimento de jogos


4 participantes

    FleX Menu 1.0.1.1

    Ghost 404
    Ghost 404
    Novato
    Novato

    Mensagens : 19
    Créditos : 5

    FleX Menu 1.0.1.1 Empty FleX Menu 1.0.1.1

    Mensagem por Ghost 404 Sex Jul 20, 2012 11:03 am

    FleX Menu 1.0.1.1

    Sou novo aqui no fórum e estou postando o primeiro tópico Very Happy

    FleX Menu 1.0.1.1 FleX_Menu_1
    esse é um menu bem legal , espero que gostem

    Creditos ao autor: Bruno Augusto

    Spoiler:
    #=========================================================
    # ** 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 Successful

    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


    Última edição por Iori Yagami em Sex Jul 20, 2012 12:08 pm, editado 1 vez(es)
    Canjoo
    Canjoo
    Experiente
    Experiente

    Mensagens : 505
    Créditos : 52

    FleX Menu 1.0.1.1 Empty Re: FleX Menu 1.0.1.1

    Mensagem por Canjoo Sex Jul 20, 2012 11:23 am

    Muito Legal esse menu!
    KnowVFX
    KnowVFX
    Semi-Experiente
    Semi-Experiente

    Mensagens : 140
    Créditos : 3

    FleX Menu 1.0.1.1 Empty Re: FleX Menu 1.0.1.1

    Mensagem por KnowVFX Sex Jul 20, 2012 11:30 am

    Legal ! +1 cred por ajudar a galerinha !


    _________________
    Programas ultilizados -
     Sony vegas pro 11
       After Effects CS4 
          
    Samuka_Maker
    Samuka_Maker
    Aldeia Friend
    Aldeia Friend

    Medalhas : FleX Menu 1.0.1.1 WBLhI
    Mensagens : 1203
    Créditos : 125

    FleX Menu 1.0.1.1 Empty Re: FleX Menu 1.0.1.1

    Mensagem por Samuka_Maker Sex Jul 20, 2012 12:06 pm

    Boa contribuição mas coloque os créditos ao Bruno Augusto no final da postágem

    @edit: em ves de spoiler coloca as tags [*code] e [*/code] sem os asteriscos (*)


    _________________

    Life rpg maker, suporte para criacao de jgoos online eoffline, link do forum:(v2.0)
    http://liferpgmakerv2.forumais.com/

    FleX Menu 1.0.1.1 6f4EA

    FleX Menu 1.0.1.1 Bxvno
    Tópico original/Tópico de Recrutamento

    Conteúdo patrocinado

    FleX Menu 1.0.1.1 Empty Re: FleX Menu 1.0.1.1

    Mensagem por Conteúdo patrocinado


      Data/hora atual: Qui Out 28, 2021 1:46 pm