Fórum iBlue
cRmGSS - Distribuição de Atributos Buddy_Group

Bem Vindos ao iBlue GAMES!

Registre-se para obter acesso especial em todo conteúdo presente no Fórum!
Tenha um bom uso do nosso fórum, e seja ativo!





Fórum iBlue
cRmGSS - Distribuição de Atributos Buddy_Group

Bem Vindos ao iBlue GAMES!

Registre-se para obter acesso especial em todo conteúdo presente no Fórum!
Tenha um bom uso do nosso fórum, e seja ativo!





Somos ÚNICOS, somos o SEU fórum


Você não está conectado. Conecte-se ou registre-se

Ver o tópico anterior Ver o tópico seguinte Ir para baixo  Mensagem [Página 1 de 1]

T-Lord

1cRmGSS - Distribuição de Atributos Empty cRmGSS - Distribuição de Atributos Dom 13 Jan 2013 - 17:03

T-Lord
Administrador
Índice de todos os scripts cRmGSS
cRmGSS - Distribuição de Atributos Bh8Bm

Distribuição de Atributos

Compativel com: RMVXAce
Compatibilidade :alta
Facilidade de uso: fácil
Lag gerado: baixo

Depois
de ter grandes problemas para achar a instância que carregava os
atributos do jogador, terminei este script, creio que o mesmo possa
agradar a alguns, enfim, espero que todos gostem.


Condições de Uso
Pode ser modificado, desde que os devidos créditos permaneçam.


Para que serve o script
Adiciona um menu de distribuição de atributos ao seu projeto


Apenas uma pequena observação, para alterar o jogador que está
recebendo os atributos, basta apertar as teclas "Q" ou "W" ( Como nos
outros menus (Equipamento, habilidades e etc) padrões do RPG Maker )



Script.
Código:
#========================================================
# 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 = 10

    #Pontos adquiridos ao upar
    Points_level = 1

    #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 = "Distribuição de atributos"

    #Nomes das opções
    HP_Name = "HP"
    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, 47)
  end
  #--------------------------------------------------------------------------
  # * Aquisição da largura da janela
  #--------------------------------------------------------------------------
  def window_width
    return 244
  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, 47, 300, 369)
    @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(1)
    @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


[center]Mais scripts do mesmo autor?
R -> Aqui


Imagens

cRmGSS - Distribuição de Atributos NocYt



Download

Não necessário


[center]Créditos e Avisos
JohnBolton pelo script, qualquer bug ou adição, basta avisar-me.
[/center][/center]

http://www.zonetoony.net/

Ver o tópico anterior Ver o tópico seguinte Ir para o topo  Mensagem [Página 1 de 1]

Tópicos semelhantes

-

» Lição 7: Atributos

Permissões neste sub-fórum
Não podes responder a tópicos