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

Lune Elemental Level

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

Imprimir
Ir para o fim Páginas1
Ações
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
06/12/2012 às 21:01 #1
Script muito bom, eu até estou usando aqui :D
Parabéns Raizen, pelo script.
06/12/2012 às 21:03 #2
Oh fico feliz que esteja usando, qualquer problema que houver com ele, só me avisar :D
04/12/2013 às 02:44 #3
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?
04/12/2013 às 12:02 #4
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.
04/12/2013 às 17:02 #5
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!
Imprimir
Ir para o topo Páginas1
Ações