O TEMA DO FÓRUM ESTÁ EM MANUTENÇÃO. FEEDBACKS AQUI: ACESSAR

Lune Elemental Level

Iniciado por Raizen, 06/12/2012 às 20:57

Lune Elemental Level

Compativel com: RMVXAce
Compatibilidade :média
Facilidade de uso: médio
Lag gerado: baixo
[box class=titlebg]
Condições de Uso
[/box]
  Pode ser modificado, e divulgado em outros lugares, mas peço que não retire os créditos.

[box class=titlebg]
Para que serve o script
[/box]

O script permite que no jogo tenha leveis para diferentes elementos, permitindo que suba niveis do mesmo e que adicionem dano extra de acordo com o level do elemento.

[box class=titlebg]
Detalhes do script
[/box]

  • Compatível com a maioria dos scripts que se baseiam no sistema de batalha padrão, ou seja, quase todos com exceção de Sistemas de batalha ativo.

  • Os elementos ficam organizados no menu de acordo com o número do mesmo.

  • fórmula de experiência, dano, cores das barras no menu, elementos que dão dano tudo configurável dentro do script.

  • Não necessita imagens.

  • Para ativar a janela de elementos, Chamar Script: SceneManager.call(Scene_Raizen_Elements)

  • Instruções no script.

    [box class=titlebg]
    Script.
    [/box]

    #=======================================================
    #         Lune Element Level
    # Autor: Raizen
    # Compativel com: RMVXAce
    # Comunidade: centrorpg.com
    # O script permite que seja possivel subir niveis de elementos
    # de acordo com o quanto cada elemento é utilizado.
    # Os niveis aumentarão o dano causado por aquele elemento.
    
    #IMPORTANTE: Não é muito simples a configuração, preste bastante
    # atenção para deixar do jeito mais desejavel possivel.
    
    # Lembrando que é possivel mudar uma afinidade elemental no próprio
    # database, na classe de cada personagem.
    
    # Para criar novos elementos, vá até a aba "Termos" dentro do database.
    
    # É compativel com a maioria dos scripts que se baseiam no sistema padrão,
    # que em geral é um número elevado.
    
    # Para chamar a janela de elementos.
    # Chamar Script: SceneManager.call(Scene_Raizen_Elements)
    
    
    module Raizen_Elements
    # Escolha os elementos do database que recebem dano
    # extra e sobem de acordo com a exp.
    
    Extra_Damage = [3,4,5,6,7,8,9,10]
    # Indique as cores de cada elemento como aparecerá na janela de Elementos.
    # Seguindo a mesma ordem dos Ids acima.
    # lembrando da ordem (r, g, b) r = red(vermelho), g = green(verde)
    # b = blue(azul)
    # Para conseguir a cor desejada, olhe essa tabela por exemplo.
    # http://shibolete.tripod.com/RGB.html
    
    Damage_Elements = [
    Color.new(255, 55, 55),
    Color.new(30, 255, 255),
    Color.new(255, 255, 30),
    Color.new(50, 50, 255),
    Color.new(92, 51, 23),
    Color.new(20, 230, 100),
    Color.new(240, 240, 240),
    Color.new(255, 255, 255),]
    
    # Mesma coisa que acima, mas dessa vez indique a nomenclatura para
    # cada elemento. Sempre entre aspas
    Name_Elements = [
    "Fogo",
    "Gelo",
    "Trovão",
    "Água",
    "Terra",
    "Vento",
    "Sagrado",
    "Sombrio",]
    
    
    
    
    # Funciona apenas com magia? Caso seja uma arma ignora 
    # o efeito de bonus de dano, além da experiência.
    # true = aceita as armas, false = ignora armas.
    Accept_Weapons = false
    
    # formula da experiência.
    # lembrando que o level é adquirido conforme a quantidade
    # de dano causado.
    
    def self.formula(level)
      level * level * 200 + 100 # modifique essa linha com os calculos da experiência.
    end
    
    # formula de dano extra a partir do level.
    
    def self.damage(level)
      l = level.to_f
      l / 10 + 1  # modifique essa linha para obter o dano extra.
    end
    
    # Quantidade de elementos no database.
    
    Size = 10
    
    # Nomenclatura do level no Menu.
    
    Lv = "Lv."
    
    # Nome que aparecerá no menu.
    Elements = "Elements"
    
    # Nome que indicará os leveis no menu.
    LevelTotal = "Level Total"
    
    end
    
    #==========================================================================
    # ======================Aqui começa o Script===============================
    #==========================================================================
    
    
    #==============================================================================
    # ** Scene_Status
    #------------------------------------------------------------------------------
    #  Esta classe executa o processamento da tela de atributos.
    #==============================================================================
    
    class Scene_Raizen_Elements < Scene_MenuBase
    
      #--------------------------------------------------------------------------
      # * Inicialização do processo
      #--------------------------------------------------------------------------
      def start
        super
        @status_window = Window_Raizen_Elements.new(@actor)
        @status_window.set_handler(:cancel,   method(:return_scene))
        @status_window.set_handler(:pagedown, method(:next_actor))
        @status_window.set_handler(:pageup,   method(:prev_actor))
        
      end
      #--------------------------------------------------------------------------
      # * Processo da mudança de herói
      #--------------------------------------------------------------------------
      def on_actor_change
        @status_window.actor = @actor
        @status_window.activate
      end
    end
    
    
    #==============================================================================
    # ** Window_Status
    #------------------------------------------------------------------------------
    #  Esta janela exibe as especificações completas na janela de atributos.
    #==============================================================================
    
    class Window_Raizen_Elements  < Window_Selectable
    include Raizen_Elements
      #--------------------------------------------------------------------------
      # * Inicialização do objeto
      #     actor : herói
      #--------------------------------------------------------------------------
      def initialize(actor)
        super(0, 0, Graphics.width, Graphics.height)
        @actor = actor
        refresh
        activate
      end
      #--------------------------------------------------------------------------
      # * Definição de herói
      #     actor : herói
      #--------------------------------------------------------------------------
      def actor=(actor)
        return if @actor == actor
        @actor = actor
        refresh
      end
      #--------------------------------------------------------------------------
      # * Renovação
      #--------------------------------------------------------------------------
      def refresh
        contents.clear
        draw_block1   (line_height * 0)
        draw_block2   (line_height * 2)
        draw_block3   (line_height * 7)
        draw_vert_line (250)
        for n in 0...Extra_Damage.size
        draw_bars(n)
        end
      end
      #--------------------------------------------------------------------------
      # * Desenho do bloco 1
      #     y : coordenada Y
      #--------------------------------------------------------------------------
      def draw_bars(n)
      y = n * 360 / Extra_Damage.size + 40
      contents.fill_rect(300, y, 200, 12, bar_color)
      contents.fill_rect(302, y + 2, 196, 8, line_color)
      x = 196
      e = Extra_Damage[n]
      x *= $affinity_exp[@actor.class_id][e] / Raizen_Elements.formula($affinity_levels[@actor.class_id][e])
      contents.fill_rect(302, y + 2, x, 8, Damage_Elements[n])
      draw_text(310, y - 14, 100, 25, Name_Elements[n], 0)
      draw_text(430, y - 14, 100, 25, Lv, 0)
      draw_text(410, y - 14, 80, 25, $affinity_levels[@actor.class_id][e], 2)
      end
      def draw_block1(y)
        draw_actor_name(@actor, 4, y)
        draw_actor_class(@actor, 128, y)
      end
      #--------------------------------------------------------------------------
      # * Desenho do bloco 1
      #     y : coordenada Y
      #--------------------------------------------------------------------------
       def bar_color
        color = Color.new(0,0,0, 150)
        color
      end 
      def draw_block2(y)
        draw_actor_face(@actor, 8, y)
        draw_exp_info(0, 330)
      end
      #--------------------------------------------------------------------------
      # * Desenho do bloco 3
      #     y : coordenada Y
      #--------------------------------------------------------------------------
      def draw_block3(y)
        draw_parameters(32, y)
      end
      #--------------------------------------------------------------------------
      # * Desenho de uma linha horzontal
      #--------------------------------------------------------------------------
      def draw_vert_line(x)
        line_x = x
        contents.fill_rect(line_x, 0, 2, contents_height, line_color)
      end
      #--------------------------------------------------------------------------
      # * Aquisção da cor da linha horizontal
      #--------------------------------------------------------------------------
      def line_color
        color = normal_color
        color.alpha = 48
        color
      end
      #--------------------------------------------------------------------------
      # * Desenho das informações básicas
      #     x : coordenada X
      #     y : coordenada Y
      #--------------------------------------------------------------------------
      def draw_basic_info(x, y)
        draw_actor_icons(@actor, x, y + line_height * 1)
        draw_actor_hp(@actor, x, y + line_height * 2)
        draw_actor_mp(@actor, x, y + line_height * 3)
      end
      #--------------------------------------------------------------------------
      # * Desenho dos parâmetros
      #     x : coordenada X
      #     y : coordenada Y
      #--------------------------------------------------------------------------
      def draw_parameters(x, y)
        6.times {|i| draw_actor_param(@actor, x, y + line_height * i, i + 2) }
      end
      #--------------------------------------------------------------------------
      # * Desenho das informações de experiência
      #     x : coordenada X
      #     y : coordenada Y
      #--------------------------------------------------------------------------
      def draw_exp_info(x, y)
        s1 = 0
        for n in 1...Raizen_Elements::Size
        s1 += $affinity_levels[@actor.class_id][n]
        end
        change_color(system_color)
        draw_text(x, y + line_height * 0, 180, line_height, LevelTotal)
        change_color(normal_color)
        draw_text(x, y + line_height * 1, 180, line_height, s1, 2)
      end
    
      #--------------------------------------------------------------------------
      # * Desenho da descrição
      #     x : coordenada X
      #     y : coordenada Y
      #--------------------------------------------------------------------------
      def draw_description(x, y)
        draw_text_ex(x, y, @actor.description)
      end
    end
    
    class Game_Actor < Game_Battler
    alias raizen_element_initialize initialize
      def initialize(actor_id)
        raizen_element_initialize(actor_id)
        if $affinity_start == nil
          $affinity_levels = []
          $affinity_exp = []
          for i in 1...$data_classes.size
            $affinity_levels[i] = Array.new(Raizen_Elements::Size + 1, 0)
            $affinity_exp[i] = Array.new(Raizen_Elements::Size + 1, 0)
          end
        $affinity_start = true
        end
      end
    end
    module DataManager
      def self.make_save_contents
        contents = {}
        contents[:system]        = $game_system
        contents[:timer]         = $game_timer
        contents[:message]       = $game_message
        contents[:switches]      = $game_switches
        contents[:variables]     = $game_variables
        contents[:self_switches] = $game_self_switches
        contents[:actors]        = $game_actors
        contents[:party]         = $game_party
        contents[:troop]         = $game_troop
        contents[:map]           = $game_map
        contents[:player]        = $game_player
        contents[:affin]         = $affinity_levels
        contents[:affinl]        = $affinity_exp
        contents
      end
    
      #--------------------------------------------------------------------------
      # * Extrair conteúdo salvo
      #--------------------------------------------------------------------------
      def self.extract_save_contents(contents)
        $game_system        = contents[:system]
        $game_timer         = contents[:timer]
        $game_message       = contents[:message]
        $game_switches      = contents[:switches]
        $game_variables     = contents[:variables]
        $game_self_switches = contents[:self_switches]
        $game_actors        = contents[:actors]
        $game_party         = contents[:party]
        $game_troop         = contents[:troop]
        $game_map           = contents[:map]
        $game_player        = contents[:player]
        $affinity_levels    = contents[:affin]
        $affinity_exp       = contents[:affinl]
      end
    end
    
    class Game_Battler < Game_BattlerBase
      def make_damage_value(user, item)
        value = item.damage.eval(user, self, $game_variables)
        value *= item_element_rate(user, item)
        value *= pdr if item.physical?
        value *= mdr if item.magical?
        value *= rec if item.damage.recover?
        value = apply_critical(value) if @result.critical
        value = apply_variance(value, item.damage.variance)
        value = apply_guard(value)
        if @class_id == nil
        value *= item_element_afinity(user.class_id, user.atk_elements.pop) 
        value.to_i
        call_exp_element(user.class_id, user.atk_elements.pop, value, item)
        end
        @result.make_damage(value.to_i, item)
      end
      def call_exp_element(id, elem, value, item)
        return if item.damage.element_id < 0 and !Raizen_Elements::Accept_Weapons 
        return unless Raizen_Elements::Extra_Damage.include?(elem)
        $affinity_exp[id][elem] += value 
        if $affinity_exp[id][elem] >= Raizen_Elements.formula($affinity_levels[id][elem])
        $affinity_exp[id][elem] = 0
        $affinity_levels[id][elem] += 1
        end
      end
      def item_element_afinity(class_id, item)
      item_damage = item
      return 1 unless item_damage >= 0 or Raizen_Elements::Accept_Weapons
      value = Raizen_Elements.damage($affinity_levels[class_id][item_damage])
      return value
      end
    end 
    


    Caso use o menu padrão e pretende adicionar essa opção nele.

    #==============================================================================
    # ** Scene_Menu
    #------------------------------------------------------------------------------
    #  Esta classe executa o processamento da tela de menu.
    #==============================================================================
    
    class Scene_Menu < Scene_MenuBase
      def create_command_window
        @command_window = Window_MenuCommand.new
        @command_window.set_handler(:item,      method(:command_item))
        @command_window.set_handler(:skill,     method(:command_personal))
        @command_window.set_handler(:equip,     method(:command_personal))
        @command_window.set_handler(:status,    method(:command_personal))
        @command_window.set_handler(:elements,  method(:command_personal))
        @command_window.set_handler(:formation, method(:command_formation))
        @command_window.set_handler(:save,      method(:command_save))
        @command_window.set_handler(:game_end,  method(:command_game_end))
        @command_window.set_handler(:cancel,    method(:return_scene))
      end
      def on_personal_ok
        case @command_window.current_symbol
        when :skill
          SceneManager.call(Scene_Skill)
        when :equip
          SceneManager.call(Scene_Equip)
        when :status
          SceneManager.call(Scene_Status)
        when :elements
          SceneManager.call(Scene_Raizen_Elements)
        end
      end
    end
    
    #==============================================================================
    # ** Window_MenuCommand
    #------------------------------------------------------------------------------
    #  Esta janela exibe os comandos do menu.
    #==============================================================================
    
    class Window_MenuCommand < Window_Command
    alias raizen_add_main_commands add_main_commands
      def add_main_commands
        raizen_add_main_commands
        add_command(Raizen_Elements::Elements, :elements, main_commands_enabled)
      end
    end
    


    Ou caso tenha mais scripts para serem imbutidos no menu, veja esse script do Zero ^^
    http://ateliercross.webege.com/codes/rgss3/option-manager/

    [box class=titlebg]
    Imagens
    [/box]

    Spoiler
    [close]

    [box class=titlebg]
    Download
    [/box]

    Não necessário

    [box class=titlebg]
    Créditos e Avisos
    [/box]

    Raizen pelo script

Script muito bom, eu até estou usando aqui :D
Parabéns Raizen, pelo script.

Oh fico feliz que esteja usando, qualquer problema que houver com ele, só me avisar :D

Fala Raizen! Estou ressuscitando sinistramente o tópico, perdão por isso, mas é que eu estou procurando vários scripts para o meu projeto e esse chamou minha atenção. O problema é que quero que ele seja uma das opções do menu, e como ainda tenho o Bestiário e um sistema de forja eu estou tentando usar o Iris Core Option Manager, que você até mencionou no tópico.

Bom, to apanhando pra fazer acontecer, Sei 0% de Script, faço apenas pequenas edições e estou confuso em como editar o Option Manager pra colocar o seu Lune Elemental como opção, e vejo que vou ficar perdido também para colocar o Bestiário e etc. Eu até faço com que a opção "Elementos" seja mostrada junto com "Status", "Equipamentos", etc, mas mesmo sendo clicada ela não mostra o menude elementos. Tem como ajudar?

Assim, antes de tudo você então vai descartar meu segundo script, ja que ele serve apenas para caso necessitasse apenas esse script no menu.

Depois disso adicione o script do Zero/Areksu nos seus scripts e você vai configurar ele da seguinte maneira.


Nessa linha você vai colocar o nome dos scripts adicionais.

Add_Names = ['Status','Teste']


Para o seu caso por exemplo você vai configurar assim.

Add_Names = ['Level Elemental','Forjar', 'Bestiário']


e nessa outra linha

  Add_Scenes = [Scene_Status,Scene_End]

Você tem que colocar o nome das Scenes, o meu no caso é esse daqui. Scene_Raizen_Elements
logo

Add_Scenes = [Scene_Raizen_Elements,Nome_Scene_Forja, Nome_Scene_Bestiario]


Esses nomes você deve encontrar dentro do script, ele fica depois de class, e 99% das vezes estarão assim

class Scene_........


Feito isso adicione aqui também o meu, poiso o meu necessita da escolha de personagens

Status_Ad = ['Level Elemental']


Requer um pouco de conhecimento em scripts, mas acho que o Areksu fez do modo mais fácil possível para configurar isso :P.

Consegui fazer com um script de edição de menu do Masked, ficou certinho. mas valeu pela ajuda! O único problema é que fica "Condições" ao invés de "Status", o que eu acho feião, mas ta tranquilo, ta funcionando.

Valeu pelo script e pela ajuda Raizen, abraço!