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

[RPGVXACE]Árvore de talentos para armas?

Iniciado por raposolucas, 27/03/2014 às 20:39

Imprimir
Ir para o fim Páginas1
Ações
27/03/2014 às 20:39 Última edição: 29/03/2014 às 21:31 por raposolucas
Salve salve amigos...

Já procurei diversas vezes mas ainda não encontrei. Mas o que eu estou procurando você deve estar pensando.
Bom, eu queria um sistema em que eu definisse uma arma principal para um determinado personagem e, quando o mesmo subir de lvl eu receber pontos de atributos os quais eu poderia incrementar nesta arma alem de receber novas habilidades de ataque, é parecido com uma árvore de talentos (como o de CASTLEVANIA: LORDS OF SHADOW 2, infelizmente não estou em casa e assim não tenho como postar uma referencia do que quero).
Qualquer coisa parecida com isto já estarei satisfeito.

Infelizmente não estou em casa e assim não tenho como postar uma referencia do que quero.
PS.: Desculpe se estou fazendo este pedido no lugar errado (e se sim, que por favor me realoquem) é que sou novo por aqui e também em fóruns.

Agradeço desde já! :ok:
Citar
"Aquele que luta com monstros deve acautelar-se para não tornar-se também um monstro. Quando se olha muito tempo para um abismo, o abismo olha para você."


Zur Genealogie der Moral - página 105, Friedrich Wilhelm Nietzsche, Ernst Holzer, Otto Crusius - C. G. Naumann, 1899.
[/b]
27/03/2014 às 21:03 #1
Eu faço,mas vai dar um trabalho,então se puder especificar mais vai ser ótimo.
29/03/2014 às 20:59 #2
OPA VALEU PELA AJUDA AMIGO!

SEGUE O ESQUEMA QUE DESEJO.

AQUI ESTÁ UM EXEMPLO DE SCRIPT, SÓ QUE ESTE É PARA EDITAR OS ATRIBUTOS DO JOGADOR. MAS SE TU PREFERIR PODE EDITAR BASEANDO-SE NESTE SCRIPT.
#========================================================
# JB{Distribuição de Atributos} - Versão 1.0
#--------------------------------------------------------
# Autor: JohnBolton
# Data : 19/03/2012
#--------------------------------------------------------
# Descrição: Permite o aumento dos status dos personagem
# utilizando pontos de distribuição ganhos ao upar.
#--------------------------------------------------------
# Instruções:
#      Para acessar a tela de distribuição
#         Evento > 3ª Aba > Chamar Script
#         Insira: SceneManager.call(Scene_Distribuct)
#
#      Adicionar pontos a um personagem
#         Evento > 3ª Aba > Chamar Script
#         Insira: $game_actors[id].points += pontos
#
#         Exemplo: $game_actors[1].points += 3
#   No tela de distribuição, utilize as teclas "Q" e "W"
#   para alterar o jogador que receberá os pontos
#========================================================
module JohnBolton92
  module Dist_Points

  #--------------------------------------------------------------------------
  # * Configurações
  #--------------------------------------------------------------------------

    #Pontos Iniciais
    Start_points = 0

    #Pontos adquiridos ao upar
    Points_level = 5

    #Atributos adquiridos de HP ao utilizar 1 ponto
    HP_Points = 10 

    #Atributos adquiridos de MP ao utilizar 1 ponto
    MP_Points = 7

    #Atributos adquiridos de Ataque ao utilizar 1 ponto
    Atack_Points = 5

    #Atributos adquiridos de Defesa ao utilizar 1 ponto
    Defense_Points = 4

    #Atributos adquiridos de Inteligencia ao utilizar 1 ponto
    Inteligence_Points = 5

    #Atributos adquiridos de Resistência ao utilizar 1 ponto
    Resistence_Points = 6

    #Atributos adquiridos de Agilidade ao utilizar 1 ponto
    Agility_Points = 7

    #Atributos adquiridos de Sorte ao utilizar 1 ponto
    Luck_Points = 8

    #Cabeçalho (Nome do Menu)
    Head_Name = "Defina corretamente os valores dos atributos.
Utilize as teclas 'Q' e 'W' para alternar de Herói."
                
    #Nomes das opções
    HP_Name = "Saúde"
    MP_Name = "MP"
    Atack_Name = "Ataque"
    Defense_Name = "Defesa"
    Inteligence_Name = "Inteligencia"
    Resistence_Name = "Resistência"
    Agility_Name = "Agilidade"
    Luck_Name = "Sorte"

    #Adicionar a opção de acesso ao Distribuição de atributos no menu?

    Active_in_Menu = true #(Obs: Só ative esta opção se usar o menu padrão)
    Option_Menu_Name = "Atributos" #Nome da opção no menu

  #--------------------------------------------------------------------------
  # * Fim das Configurações
  #--------------------------------------------------------------------------
  
    module_function
  
    def setup(actor)
      cond = Array.new(8)
      cond[0] = actor.hp  >= actor.param_max(1) ? false : true
      cond[1] = actor.mp  >= actor.param_max(1) ? false : true
      cond[2] = actor.atk >= actor.param_max(2) ? false : true
      cond[3] = actor.def >= actor.param_max(3) ? false : true
      cond[4] = actor.mat >= actor.param_max(4) ? false : true
      cond[5] = actor.mdf >= actor.param_max(5) ? false : true
      cond[6] = actor.agi >= actor.param_max(6) ? false : true
      cond[7] = actor.luk >= actor.param_max(7) ? false : true
      @cond = cond
    end
  
    def get
      return @cond
    end
  
  end
end

#==============================================================================
# ** Window_DistribuctCommand
#------------------------------------------------------------------------------
#  Esta janela exibe os comandos para a distribuição de atributos
#==============================================================================

class Window_DistribuctCommand < Window_Command
  include JohnBolton92::Dist_Points
  #--------------------------------------------------------------------------
  # * Inicialização do processo
  #--------------------------------------------------------------------------
  def initialize
    super(300, 70)
  end
  #--------------------------------------------------------------------------
  # * Aquisição da largura da janela
  #--------------------------------------------------------------------------
  def window_width
    return 245
  end
  #--------------------------------------------------------------------------
  # * Criação da lista de comandos
  #--------------------------------------------------------------------------
  def make_command_list
    add_main_commands
  end
  #--------------------------------------------------------------------------
  # * Adição dos comandos principais
  #--------------------------------------------------------------------------
  def add_main_commands
    m_actor = JohnBolton92::Dist_Points
    points = $game_system.points_enabled
    add_command(HP_Name,         :hp,     points && m_actor.get[0])
    add_command(MP_Name,         :mp,     points && m_actor.get[1])
    add_command(Atack_Name,      :atack,  points && m_actor.get[2])
    add_command(Defense_Name,    :defense,points && m_actor.get[3])
    add_command(Inteligence_Name,:int,    points && m_actor.get[4]) 
    add_command(Resistence_Name, :res,    points && m_actor.get[5])
    add_command(Agility_Name,    :agility,points && m_actor.get[6])
    add_command(Luck_Name,       :luck,   points && m_actor.get[7])
  end
end

class Window_DistribuctStatus < Window_Selectable
  #--------------------------------------------------------------------------
  # * Inicialização do processo
  #--------------------------------------------------------------------------
  def initialize(actor)
    super(0, 70, 300, 346)
    @actor = actor
    refresh
    activate
  end
  #--------------------------------------------------------------------------
  # * Atualização da Window
  #--------------------------------------------------------------------------
  def refresh; contents.clear
    module_actor = JohnBolton92::Dist_Points
    module_actor.setup(@actor)
    draw_block1   (line_height * 0)
    draw_block2   (line_height * 2)
    draw_block3   (line_height * 7)
  end
  #--------------------------------------------------------------------------
  # * Definição de herói selecionado no menu
  #     actor : herói
  #--------------------------------------------------------------------------
  def actor=(actor)
    return if @actor == actor
    @actor = actor
    refresh
  end
  #--------------------------------------------------------------------------
  # * Desenho do bloco 1
  #     y : coordenada Y
  #--------------------------------------------------------------------------
  def draw_block1(y)
    draw_actor_name(@actor, 4, y)
    draw_actor_class(@actor, 128, y)
    draw_actor_nickname(@actor, 288, y)
  end
  #--------------------------------------------------------------------------
  # * Desenho do bloco 2
  #     y : coordenada Y
  #--------------------------------------------------------------------------
  def draw_block2(y)
    draw_actor_face(@actor, 8, y)
    draw_basic_info(136, y)
  end
  #--------------------------------------------------------------------------
  # * Desenho do bloco 3
  #     y : coordenada Y
  #--------------------------------------------------------------------------
  def draw_block3(y)
    draw_parameters(32, y)
  end
  #--------------------------------------------------------------------------
  # * Desenho das informações básicas
  #     x : coordenada X
  #     y : coordenada Y
  #--------------------------------------------------------------------------
  def draw_basic_info(x, y)
    draw_actor_level(@actor, x, y + line_height * 0)
    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
end

class Scene_Distribuct < Scene_MenuBase
  include JohnBolton92::Dist_Points
  #--------------------------------------------------------------------------
  # * Inicialização do processo
  #--------------------------------------------------------------------------
  def start
    super
    create_help_window
  end
  #--------------------------------------------------------------------------
  # * Criação da janela de ajuda.
  #--------------------------------------------------------------------------
  def create_help_window
    @help_window = Window_Help.new(2)
    @help_window.set_text(Head_Name)
    @help_window_points = Window_Help.new(1)
    @help_window_points.set_text("Pontos: " + @actor.points.to_s)
    @help_window_points.x, @help_window_points.y = 300, 366
    @help_window_points.width, @help_window_points.height = 244, 50
    @status_window = Window_DistribuctStatus.new(@actor)
    @window_options = Window_DistribuctCommand.new
    create_command_window_status
    create_command_window_distribucts
  end
  #--------------------------------------------------------------------------
  # * Criação da janela de status.
  #--------------------------------------------------------------------------
  def create_command_window_status
    @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
  #--------------------------------------------------------------------------
  # * Criação da janela de comandos.
  #--------------------------------------------------------------------------
  def create_command_window_distribucts
    @window_options.set_handler(:hp, method(:hp))
    @window_options.set_handler(:mp, method(:mp))
    @window_options.set_handler(:atack, method(:atack))
    @window_options.set_handler(:defense, method(:defense))
    @window_options.set_handler(:int, method(:int))
    @window_options.set_handler(:res, method(:res))
    @window_options.set_handler(:agility, method(:agility))
    @window_options.set_handler(:luck, method(:luck))
  end
  #--------------------------------------------------------------------------
  # * Atualização da tela
  #--------------------------------------------------------------------------
  def update
    Graphics.update
    Input.update
    check_points
    update_windows
    refresh_windows
  end
  #--------------------------------------------------------------------------
  # * Atualização das windows
  #--------------------------------------------------------------------------
  def update_windows
    @status_window.update
    @window_options.update
    @help_window.update
    @help_window_points.set_text("Pontos: " + @actor.points.to_s)
  end
  #--------------------------------------------------------------------------
  # * Checagem da quantidade pontos
  #--------------------------------------------------------------------------
  def check_points
    if @actor.points > 0
      $game_system.points_enabled = true
    else
      $game_system.points_enabled = false
    end
  end
  #--------------------------------------------------------------------------
  # * Atualização algumas windows
  #--------------------------------------------------------------------------
  def refresh_windows
    @window_options.refresh
  end
  #--------------------------------------------------------------------------
  # * Processo da mudança de herói
  #--------------------------------------------------------------------------
  def on_actor_change
    @status_window.actor = @actor
    @status_window.activate
  end
  #--------------------------------------------------------------------------
  # * Processa a distribuição
  #     param_id : Parametro a aumentar
  #--------------------------------------------------------------------------
  def distribuct(param_id)
    @actor.add_param(param_id, @atribucts)
  end
  #--------------------------------------------------------------------------
  # * Aumento de HP
  #--------------------------------------------------------------------------
  def hp
    @atribucts = HP_Points
    distribuct(0)
    @select = :hp
    take_off
  end
  #--------------------------------------------------------------------------
  # * Aumento de MP
  #--------------------------------------------------------------------------
  def mp
    @atribucts = MP_Points
    distribuct(1)
    @select = :mp
    take_off
  end
  #--------------------------------------------------------------------------
  # * Aumento de Demage
  #--------------------------------------------------------------------------
  def atack
    @atribucts = Atack_Points
    distribuct(2)
    @select = :atack
    take_off
  end
  #--------------------------------------------------------------------------
  # * Aumento de Defesa
  #--------------------------------------------------------------------------
  def defense
    @atribucts = Defense_Points
    distribuct(3)
    @select = :defense
    take_off
  end
  #--------------------------------------------------------------------------
  # * Aumento de Inteligência
  #--------------------------------------------------------------------------
  def int
    @atribucts = Inteligence_Points
    distribuct(4)
    @select = :int
    take_off
  end
  #--------------------------------------------------------------------------
  # * Aumento de Resistência
  #--------------------------------------------------------------------------
  def res
    @atribucts = Resistence_Points
    distribuct(5)
    @select = :res
    take_off
  end
  #--------------------------------------------------------------------------
  # * Aumento de Agildade
  #--------------------------------------------------------------------------
  def agility
    @atribucts = Agility_Points
    distribuct(6)
    @select = :agility
    take_off
  end
  #--------------------------------------------------------------------------
  # * Aumento de Sorte
  #--------------------------------------------------------------------------
  def luck
    @atribucts = Luck_Points
    distribuct(7)
    @select = :luck
    take_off
  end
  #--------------------------------------------------------------------------
  # * Retira os pontos gastos
  #--------------------------------------------------------------------------
  def take_off
    @actor.points -= 1
    terminate
    create_help_window
    @window_options.select_symbol(@select)
  end
  #--------------------------------------------------------------------------
  # * Finalização do processo
  #--------------------------------------------------------------------------
  def terminate
    @status_window.dispose
    @window_options.dispose
    @help_window_points.dispose
    @help_window.dispose
  end
end

#==============================================================================
# ** Window_MenuCommand
#------------------------------------------------------------------------------
#  Esta janela exibe os comandos do menu.
#==============================================================================

class Window_MenuCommand < Window_Command
  if JohnBolton92::Dist_Points::Active_in_Menu
    #--------------------------------------------------------------------------
    # * Modificação da adição do comando de formação
    #--------------------------------------------------------------------------
    alias dist_bolton_make_command_list add_formation_command
    def add_formation_command
      add_dist_points
      dist_bolton_make_command_list
    end
    #--------------------------------------------------------------------------
    # * Inclue a opção de Distribuição do Menu
    #--------------------------------------------------------------------------
    def add_dist_points
      add_command(JohnBolton92::Dist_Points::Option_Menu_Name, :dist)
    end
  end
end

#==============================================================================
# ** Scene_Menu
#------------------------------------------------------------------------------
#  Esta classe executa o processamento da tela de menu.
#==============================================================================

class Scene_Menu < Scene_MenuBase
  include JohnBolton92::Dist_Points
  if Active_in_Menu
    #--------------------------------------------------------------------------
    # * Criação da janela de comando
    #--------------------------------------------------------------------------
    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(:formation, method(:command_formation))
      @command_window.set_handler(:dist, method(:dist))
      @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
  end
  #--------------------------------------------------------------------------
  # * Chama o script
  #--------------------------------------------------------------------------
  def dist
    SceneManager.call(Scene_Distribuct)
  end
end

#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
#  Esta classe gerencia os heróis. Ela é utilizada internamente pela classe
# Game_Actors ($game_actors). A instância desta classe é referenciada
# pela classe Game_Party ($game_party).
#==============================================================================

class Game_Actor < Game_Battler
  include JohnBolton92::Dist_Points
  attr_accessor :points
  def points
    return @points
  end
  #--------------------------------------------------------------------------
  # * Modificação da inicialização do processo
  #--------------------------------------------------------------------------
  alias bolton_distri_initialize initialize unless $@
  def initialize(*args)
    bolton_distri_initialize(*args)
    case Start_points
    when String,Symbol
      @points = 0
      msgbox("Defina corretamente os valores dos atributos")
    when Integer
      @points = Start_points
    when Float
      @points = Start_points.to_i
    end
  end
  alias bolton_level_up level_up
  def level_up
    @points += Points_level
    bolton_level_up
  end
end

#==============================================================================
# ** Game_System
#------------------------------------------------------------------------------
#  Esta classe gerencia os dados relacionados ao sistema. Também gerencia
# veículos, BGM, etc.
# A instância desta classe é referenciada por $game_system.
#==============================================================================

class Game_System
  attr_accessor :points_enabled
  #--------------------------------------------------------------------------
  # * Modificação da inicialização do processo
  #--------------------------------------------------------------------------
  alias bolton92_distribuct_initialize initialize
  def initialize
    @points_enabled = nil
    bolton92_distribuct_initialize
  end
end


CREIO QUE TODAS AS INFORMAÇÕES ESTÃO NA IMAGEM, QUALQUER DÚVIDA ME MANDE UMA MSG.
VALEU MESMO PELA AJUDA CARA!!

[Anexo excluído pelo administrador]
Citar
"Aquele que luta com monstros deve acautelar-se para não tornar-se também um monstro. Quando se olha muito tempo para um abismo, o abismo olha para você."


Zur Genealogie der Moral - página 105, Friedrich Wilhelm Nietzsche, Ernst Holzer, Otto Crusius - C. G. Naumann, 1899.
[/b]
29/03/2014 às 21:58 #3 Última edição: 29/03/2014 às 22:16 por Legendary Paladin
Eu pretendo fazer por eventos amigo,por ser mais facil de fazer e editar.Um script assim demoraria muito e
acredito que ninguém o faria ... Mas não ser preocupe,ficará igual o desejado !

@Edit:Você não prefere aquela árvore de talentos mesmo não?Ela é muito mais bonita...
Spoiler
[close]
29/03/2014 às 22:32 #4
boa noite meu caro.

Realmente a do castlevania é muito mais bonita aliás sou MUITO FAN DE CASTLEVANIA, mas esta escolha é porque assim combina mais com o estilo do menu que implantei no jogo.
Citar
"Aquele que luta com monstros deve acautelar-se para não tornar-se também um monstro. Quando se olha muito tempo para um abismo, o abismo olha para você."


Zur Genealogie der Moral - página 105, Friedrich Wilhelm Nietzsche, Ernst Holzer, Otto Crusius - C. G. Naumann, 1899.
[/b]
Imprimir
Ir para o topo Páginas1
Ações