RTP Extractor

RTP Extractor

por zecomeia

Introdução

Extrai para o seu projeto os arquivos do RTP que estão em uso no projeto. Isso evita ter que copiar o RTP inteiro para o seu projeto na hora da criação do disco de jogo, ou que o jogador precise ter o RTP instalado para poder jogar.

Características

• Não sobre escreve arquivo de mesmo nome que exista na pasta do projeto.
• O processo é rápido e pode ser acompanhado por uma barra de progresso.
• Um arquivo(extract_log.txt) listando todos os arquivos copiados e seus respectivos tamanhos é gerado na pasta raiz do projeto.

Histórico

04/02/2011 v1.0.0
- Lançado o script

05/02/2011 v1.0.1
- Leitura do nome da DLL do projeto consertado
- Bug quando há mais de dois comandos "mover evento" na mesma página consertado


Como Usar

• cole acima de Main
• salve e execute o projeto
• espere o processo de extração terminar
• agora você já pode retirar o script do projeto

*O ideal é usá-lo antes de criar o disco de jogo, ou seja, quando o projeto estiver pronto para jogar, porque daí, teoricamente, nesse ponto o projeto não precisa mais ser alterado.

Script

#======================================================
# RTP Extractor
#------------------------------------------------------
#version: 1.0.1
#by:      zecomeia
#date:    05/01/2011
#for:     RGSS
#credits and thanks:
#- vgvgf (get path function from Aleworks Library)
#- Farenheight (justname and extension File methods
#[modified by me])
#- Rafidelis (get RGSS dll name funcion)
#- PLM (reported a bug)
#------------------------------------------------------
#more infos: http://colmeia-do-ze.co.cc
#tags: RTP, Extractor, RGSS
#------------------------------------------------------
#how to use:
#- paste above of Main script
#- save and play the project
#- wait exctraction end
#- now you can remove the script from your project
#
#*in project root folder will be generated an extract
#log(extract_log.txt) listing all files copied to the
#project
#==============http://colmeia-do-ze.co.cc==============

class File
 
  def self.ext(fname)
    fname = basename(fname)
    parts = fname.sub(/[^\.]*\./,'')
  end
 
  def self.justname(fname)
    basename(fname, "." + ext(fname))
  end

  def self.fcopy(src, dest)
    src = File.open(src, "rb")
    dest = File.new(dest,"wb")
    src.each_byte do |x|
      dest.putc(x)
    end
    dest.close
    src.close
  end

end

fini = File.open('Game.ini', 'r')
for line in fini.readlines
  if line =~ /Library=/
    GameDLL = File.justname($')
  end
end
fini.close

####vgvgf
RGSSGetRTPPath = Win32API.new(GameDLL, 'RGSSGetRTPPath', 'L', 'L')
RGSSGetPathWithRTP = Win32API.new(GameDLL, 'RGSSGetPathWithRTP', 'L', 'P')
def get_rtp_path(rtp = 0)
  RGSSGetPathWithRTP.call(RGSSGetRTPPath.call(rtp))
end
RGSSRTP_PATH = get_rtp_path(1)
####

module RTP_EXTRACTOR
  Data_actors        = load_data("Data/Actors.rxdata")
  Data_classes       = load_data("Data/Classes.rxdata")
  Data_skills        = load_data("Data/Skills.rxdata")
  Data_items         = load_data("Data/Items.rxdata")
  Data_weapons       = load_data("Data/Weapons.rxdata")
  Data_armors        = load_data("Data/Armors.rxdata")
  Data_enemies       = load_data("Data/Enemies.rxdata")
  Data_troops        = load_data("Data/Troops.rxdata")
  Data_states        = load_data("Data/States.rxdata")
  Data_animations    = load_data("Data/Animations.rxdata")
  Data_tilesets      = load_data("Data/Tilesets.rxdata")
  Data_common_events = load_data("Data/CommonEvents.rxdata")
  Data_system        = load_data("Data/System.rxdata")
  Data_mapinfos      = load_data("Data/MapInfos.rxdata")

  #Coisa de Preguiçoso XD
  ls = []
  Dir.foreach(RGSSRTP_PATH + "\\Graphics") { |x| ls.push(x) }
  ls.delete('.')
  ls.delete('..')
  ls.each do |x|
    str_eval = "#{x} = RGSSRTP_PATH + \"\\\\Graphics\\\\#{x}\""
    eval(str_eval)
  end
  ls = []
  Dir.foreach(RGSSRTP_PATH + "\\Audio") { |x| ls.push(x) }
  ls.delete('.')
  ls.delete('..')
  ls.each do |x|
    str_eval = "#{x} = RGSSRTP_PATH + \"\\\\Audio\\\\#{x}\""
    eval(str_eval)
  end
  #Coisa de preguiçoso END
end

class RTP_Extractor
 
  include RTP_EXTRACTOR
 
  attr_reader :files_size
  attr_reader :list
 
  def initialize()
    @files_size = 0
    @list = []
  end
 
  #list files in a folder
  #if ext = true the file extension print together
  def list_files(dir,ext=true)
    ls = []
    Dir.foreach(dir) {|x| ls.push(x) }
    ls.delete('.')
    ls.delete('..')
    if ext
      return(ls)
    else
      ls_noext = []
      ls.each { |x| ls_noext.push(File.justname(x)) }
      return(ls_noext)
    end
  end
 
  def map_events(map, file_list, command, move_command=[], parameter_204_0=false)
    code = command[0]
    parameter = command[1]
    misc_name = command[2]
    str_eval = "command.parameters\[#{parameter}\]#{misc_name}"
    unless move_command.empty?
      move_code = move_command[0]
      move_parameter = move_command[1]
      move_misc_name = move_command[2]
      move_str_eval = "mv_command.parameters\[#{move_parameter}\]#{move_misc_name}"
    end
    for event in map.events
      for page in event[1].pages
        if page.move_type == 3
          for pre_mv_command in page.move_route.list
            if pre_mv_command.code == move_code and !move_command.empty?
              fname = eval("pre_"+move_str_eval)
              unless file_list.include?(fname)
                file_list.push(fname)
              end
            end
          end
        end
        for command in page.list
          if command.code == 204
            if command.parameters[0] == parameter_204_0
              fname = eval(str_eval)
              unless file_list.include?(fname)
                file_list.push(fname)
              end
            end
          elsif command.code == 209 and !move_command.empty?
            for mv_command in command.parameters[1].list
              if mv_command.code == move_code
                fname = eval(move_str_eval)
                unless file_list.include?(fname)
                  file_list.push(fname)
                end
              end
            end
          elsif command.code == code
            fname = eval(str_eval)
            unless file_list.include?(fname)
              file_list.push(fname)
            end
          end
        end
      end
    end
  end
 
  def commons_events(file_list, command, move_command=[], parameter_204_0=false)
    code = command[0]
    parameter = command[1]
    misc_name = command[2]
    str_eval = "command.parameters\[#{parameter}\]#{misc_name}"
    unless move_command.empty?
      move_code = move_command[0]
      move_parameter = move_command[1]
      move_misc_name = move_command[2]
      move_str_eval = "mv_command.parameters\[#{move_parameter}\]#{move_misc_name}"
    end
    for command in Data_common_events[1].list     
      if command.code == 204
        if command.parameters[0] == parameter_204_0
          fname = eval(str_eval)
          unless file_list.include?(fname)
            file_list.push(fname)
          end
        end
      elsif command.code == 209 and !move_command.empty?
        for mv_command in command.parameters[1].list
          if mv_command.code == move_code
            fname = eval(move_str_eval)
            unless file_list.include?(fname)
              file_list.push(fname)
            end
          end
        end
      elsif command.code == code
        fname = eval(str_eval)
        unless file_list.include?(fname)
          file_list.push(fname)
        end
      end
    end
  end
 
  def troops_events(file_list, command, move_command=[], parameter_204_0=false)
    code = command[0]
    parameter = command[1]
    misc_name = command[2]
    str_eval = "command.parameters\[#{parameter}\]#{misc_name}"
    unless move_command.empty?
      move_code = move_command[0]
      move_parameter = move_command[1]
      move_misc_name = move_command[2]
      move_str_eval = "mv_command.parameters\[#{move_parameter}\]#{move_misc_name}"
    end
    for troop in Data_troops
      next if troop.nil?
      for page in troop.pages
        for command in page.list
          if command.code == 204
            if command.parameters[0] == parameter_204_0
              fname = eval(str_eval)
              unless file_list.include?(fname)
                file_list.push(fname)
              end
            end
          elsif command.code == 209 and !move_command.empty?
            for mv_command in command.parameters[1].list
              if mv_command.code == move_code
                fname = eval(move_str_eval)
                unless file_list.include?(fname)
                  file_list.push(fname)
                end
              end
            end
          elsif command.code == code
            fname = eval(str_eval)
            unless file_list.include?(fname)
              file_list.push(fname)
            end
          end
        end
      end
    end
  end
 
  def push_in(file_list, data, misc_name)
    for d in data
      next if d.nil?
      fname = eval("d#{misc_name}")
      unless file_list.include?(fname)
        file_list.push(fname)
      end
    end
  end
 
  #add to general file list
  def add2list(file_list, folder_in_path)
    ls = list_files(folder_in_path)
    ls_noext = list_files(folder_in_path, false)
    for name in file_list
      if ls_noext.include?(name)
        file_name = ls[ls_noext.index(name)]
        file = folder_in_path + "\\#{file_name}"
        @list.push(file)
      end
    end
  end
   
  #prepare the list os files to extract
  def extract_list()
     #######
    # AUDIO #
     #######
     
    #############################################
    #BGMs
   
    bgms = []   
    for i in 1..Data_mapinfos.size
      map = load_data(sprintf("Data/Map%03d.rxdata", i))
      bgms.push(map.bgm.name)
      map_events(map, bgms, [132, 0, '.name'])
      map_events(map, bgms, [241, 0, '.name'])
    end
    commons_events(bgms, [132, 0, '.name'])
    commons_events(bgms, [241, 0, '.name'])
    troops_events(bgms, [132, 0, '.name'])
    troops_events(bgms, [241, 0, '.name'])
    bgms.push(Data_system.title_bgm.name)
    bgms.push(Data_system.battle_bgm.name)
    add2list(bgms, BGM)
   
    #############################################
    #BGSs
   
    bgss = []
    for i in 1..Data_mapinfos.size
      map = load_data(sprintf("Data/Map%03d.rxdata", i))
      bgss.push(map.bgs.name)
      map_events(map, bgss, [245, 0, '.name'])
    end
    commons_events(bgss, [245, 0, '.name'])
    troops_events(bgss, [245, 0, '.name'])   
    add2list(bgss, BGS)
   
    #############################################
    #MEs
   
    mes = []   
    for i in 1..Data_mapinfos.size
      map = load_data(sprintf("Data/Map%03d.rxdata", i))
      map_events(map, mes, [133, 0, '.name'])
      map_events(map, mes, [249, 0, '.name'])
    end
    commons_events(mes, [133, 0, '.name'])
    commons_events(mes, [249, 0, '.name'])
    troops_events(mes, [133, 0, '.name'])
    troops_events(mes, [249, 0, '.name'])
    mes.push(Data_system.battle_end_me.name)
    mes.push(Data_system.gameover_me.name)
    add2list(mes, ME)
   
    #############################################
    #SEs
   
    ses = []
    push_in(ses, Data_items, ".menu_se.name")
    push_in(ses, Data_skills, ".menu_se.name")
    animations = Data_animations
    for i in 1...animations.size     
      for j in 0...animations[i].timings.size
        unless ses.include?(animations[i].timings[j].se.name)
          ses.push(animations[i].timings[j].se.name)
        end
      end
    end   
    for i in 1..Data_mapinfos.size
      map = load_data(sprintf("Data/Map%03d.rxdata", i))
      map_events(map, ses, [250, 0, '.name'], [44, 0, '.name'])
    end
    commons_events(ses, [250, 0, '.name'], [44, 0, '.name'])
    troops_events(ses, [250, 0, '.name'], [44, 0, '.name'])
    ses.push(Data_system.cursor_se.name)
    ses.push(Data_system.decision_se.name)
    ses.push(Data_system.cancel_se.name)
    ses.push(Data_system.buzzer_se.name)
    ses.push(Data_system.equip_se.name)
    ses.push(Data_system.shop_se.name)
    ses.push(Data_system.save_se.name)
    ses.push(Data_system.load_se.name)
    ses.push(Data_system.battle_start_se.name)
    ses.push(Data_system.escape_se.name)
    ses.push(Data_system.actor_collapse_se.name)
    ses.push(Data_system.enemy_collapse_se.name)
    add2list(ses, SE)

     ##########
    # GRAPHICS #
     ##########
   
    #############################################
    #Animations
   
    animations_names = []
    push_in(animations_names, Data_animations, ".animation_name")
    add2list(animations_names, Animations)
   
    #############################################
    #Autotiles
   
    autotiles_names = []
    for i in 1..Data_mapinfos.size
      map = load_data(sprintf("Data/Map%03d.rxdata", i))
      tileset = Data_tilesets[map.tileset_id]
      push_in(autotiles_names, tileset.autotile_names , "")
    end
    add2list(autotiles_names, Autotiles)
   
    #############################################
    #Battlebacks
   
    battlebacks_names = []
    for i in 1..Data_mapinfos.size
      map = load_data(sprintf("Data/Map%03d.rxdata", i))
      tileset = Data_tilesets[map.tileset_id]
      unless battlebacks_names.include?(tileset.battleback_name)
        battlebacks_names.push(tileset.battleback_name)
      end
      map_events(map, battlebacks_names, [204, 1, ''], [], 2)
    end
    commons_events(battlebacks_names, [204, 1, ''], [], 2)
    troops_events(battlebacks_names, [204, 1, ''], [], 2)
    add2list(battlebacks_names, Battlebacks)
   
    #############################################
    #Battlers
   
    battlers = []   
    push_in(battlers, Data_actors, ".battler_name")
    push_in(battlers, Data_enemies, ".battler_name")
    for i in 1..Data_mapinfos.size
      map = load_data(sprintf("Data/Map%03d.rxdata", i))
      map_events(map, battlers, [322, 3, ''])
    end
    commons_events(battlers, [322, 3, ''])
    troops_events(battlers, [322, 3, ''])
    add2list(battlers, Battlers)
   
    #############################################
    #Characters
   
    characters = []
    push_in(characters, Data_actors, ".character_name")
    for i in 1..Data_mapinfos.size
      map = load_data(sprintf("Data/Map%03d.rxdata", i))
      for event in map.events
        for page in event[1].pages
          unless characters.include?(page.graphic.character_name)
            characters.push(page.graphic.character_name)
          end
        end
      end
      map_events(map, characters, [322, 1, ''], [41, 0, ''])
    end
    commons_events(characters, [322, 1, ''], [41, 0, ''])
    troops_events(characters, [322, 1, ''], [41, 0, ''])
    add2list(characters, Characters)

    #############################################
    #Fogs
   
    fogs_names = []
    for i in 1..Data_mapinfos.size
      map = load_data(sprintf("Data/Map%03d.rxdata", i))
      tileset = Data_tilesets[map.tileset_id]
      unless fogs_names.include?(tileset.fog_name)
        fogs_names.push(tileset.fog_name)
      end
      map_events(map, fogs_names, [204, 1, ''], [], 1)
    end
    commons_events(fogs_names, [204, 1, ''], [], 1)
    troops_events(fogs_names, [204, 1, ''], [], 1)
    add2list(fogs_names, Fogs)
   
    #############################################
    #Gameovers
   
    gameover = [Data_system.gameover_name]
    add2list(gameover, Gameovers)
   
    #############################################
    #Icons
   
    icons = []
    push_in(icons, Data_skills, ".icon_name")
    push_in(icons, Data_items, ".icon_name")
    push_in(icons, Data_weapons, ".icon_name")
    push_in(icons, Data_armors, ".icon_name")
    add2list(icons, Icons)
   
    #############################################
    #Panoramas
   
    panoramas_names = []
    for i in 1..Data_mapinfos.size
      map = load_data(sprintf("Data/Map%03d.rxdata", i))
      tileset = Data_tilesets[map.tileset_id]
      unless panoramas_names.include?(tileset.panorama_name)
        panoramas_names.push(tileset.panorama_name)
      end
      map_events(map, panoramas_names, [204, 1, ''], [], 0)
    end
    commons_events(panoramas_names, [204, 1, ''], [], 0)
    troops_events(panoramas_names, [204, 1, ''], [], 0)
    add2list(panoramas_names, Panoramas)
   
    #############################################
    #Tilesets
   
    tilesets_names = []
    for i in 1..Data_mapinfos.size
      map = load_data(sprintf("Data/Map%03d.rxdata", i))
      tileset = Data_tilesets[map.tileset_id]
      unless tilesets_names.include?(tileset.tileset_name)
        tilesets_names.push(tileset.tileset_name)
      end
    end
    add2list(tilesets_names, Tilesets)
   
    #############################################
    #Titles
   
    title = [Data_system.title_name]
    add2list(title, Titles)
   
    #############################################
    #Transitions
   
    transitions = []
    transitions.push(Data_system.battle_transition)
    for i in 1..Data_mapinfos.size
      map = load_data(sprintf("Data/Map%03d.rxdata", i))
      map_events(map, transitions, [222, 0, ''])
    end
    commons_events(transitions, [222, 0, ''])
    troops_events(transitions, [222, 0, ''])
    add2list(transitions, Transitions)
   
    #############################################
    #Windowskins
   
    windowskins = []
    windowskins.push(Data_system.windowskin_name)
    for i in 1..Data_mapinfos.size
      map = load_data(sprintf("Data/Map%03d.rxdata", i))
      map_events(map, windowskins, [131, 0, ''])
    end
    commons_events(windowskins, [131, 0, ''])
    troops_events(windowskins, [131, 0, ''])
    add2list(windowskins, Windowskins)
   
    #delete match file between RTP and project
    #calculate the list data size
    for i in 0...@list.size
      dest = @list[i].dup
      dest.sub!("#{RGSSRTP_PATH}",'')
      if FileTest.exist?( ".#{dest}" )
        @list[i] = nil
      else       
        @files_size += FileTest.size(@list[i])
      end
    end
    #delete nil, empty and repeated from list
    @list.delete('')
    @list.compact!
    @list.uniq!
   
    return @list
  end
 
end

class Window_Progress < Window_Base
 
  def initialize(total_files_size)
    super(320-125, 240-60, 250, 110)
    self.contents = Bitmap.new(width - 32, height - 32)
        self.contents.font.name = 'Arial'
    self.contents.font.size = 20
    self.opacity = 0
    @total_files_size = total_files_size
    refresh()
  end
 
  def refresh(progress_string='', progress_files_size=0)
    return if @total_files_size == 0
    self.contents.clear
    self.contents.draw_text(4, 15, 220, 24, progress_string)
    self.contents.fill_rect(5,0,202,10,Color.new(200,200,200,200))
    self.contents.fill_rect(6,1,progress_files_size*200/@total_files_size,8,Color.new(0,0,200,200))
  end

end

rtp_extract = RTP_Extractor.new
print 'start'
flist = rtp_extract.extract_list()
total_files_size = rtp_extract.files_size
progress_files_size = 0
$game_system = load_data("Data/System.rxdata")
window_progress = Window_Progress.new(total_files_size)
$game_system = nil
n_files = 0
flog = File.new('extract_log.txt', 'a')
flog.puts('start...')
for src in flist
  dest = src.dup
  progress_string = 'copying ' + File.basename(dest)
  file_size = FileTest.size(dest)
  dest.sub!("#{RGSSRTP_PATH}",'')
  next if FileTest.exist?( ".#{dest}" )
  progress_files_size += file_size
  n_files += 1 
  window_progress.refresh(progress_string, progress_files_size)
  Graphics.update()
  File.fcopy(src, ".#{dest}" )
  str_log = ".#{dest} #{progress_files_size/1000} KB"
  flog.puts(str_log)
end
str_log = n_files.to_s+" files\n"+(progress_files_size/1000000).to_s+' MB('+(progress_files_size/1000).to_s+" KB)"
flog.puts(str_log)
flog.close
window_progress.dispose
print str_log
exit(0)

Créditos e Agradecimentos

• Feito por zecomeia
• vgvgf pela função para obter o path do RTP(retirado de seu script Aleworks Library)
• Farenheight pelos métodos #justname e #extension(editei) da classe File
• aos criadores do RMTool(programa que faz algo do tipo no RM2k) pela ideia
• Rafidelis pelo código melhorado para obter o nome da dll do jogo
• PLM por repotar bugs.

XP Wave Effect

XP Wave Effect

por zecomeia

Introdução

Modificações na classe Sprite para usar o efeito "wave" existente apenas no RGSS2.

Características

• Muito fiel ao efeito do RMVX

Screen Shot



Como Usar

• Cole o script acima de main;
• Use da mesma forma como é usado no RGSS2, se não souber procure pelo manual de referencia ao RGSS no próprio arquivo de help do RMVX. 

Demo

Dowload da demo

Script

#========================================
# XP Wave Effect
#----------------------------------------
#by:      zecomeia
#date:    01/03/2010
#for:     RGSS
#version: 1.0
#www.colmeia-do-ze.blogspot.com
#----------------------------------------
=begin
Reproduction of the VX's wave effect
(see the help file of the RPGMaker VX 
in the RGSS manual reference topic)
=end

#==============#
# Sprite class #
#==============#
class Sprite
  
  include Math
  
  attr_accessor   :wave_amp
  attr_accessor   :wave_length
  attr_accessor   :wave_speed
  attr_accessor   :wave_phase
  attr_accessor   :temp_bitmap
  
  alias initialize default_initialize rescue nil
  alias default_initialize initialize
  def initialize(viewport=nil)
    @wave_amp = 0
    @wave_length = 180
    @wave_speed = 360
    @wave_phase = 0.0
    default_initialize(viewport)
    @temp_bitmap = nil
  end
  
  alias update default_update rescue nil
  alias default_update update  
  def update()
    # the wave effect only works if wave_amp
    # propertie is a number more than zero
    wave_effect if @wave_amp > 0
    default_update()
  end
  
  # Return the width of image, because when use
  # obj.bitmap.width the value will be more than
  # the original value(because effect)
  def width()
    return (self.bitmap.width - @wave_amp * 2)
  end
    
  #---------------
  # Wave Effect
  #---------------
  def wave_effect()
    return if self.bitmap.nil?
    @temp_bitmap = self.bitmap if @temp_bitmap.nil?
    cw = @temp_bitmap.width + (@wave_amp * 2)
    ch = @temp_bitmap.height
    # Follow the VX wave effect, each horizontal line
    # has 8 pixel of height. This device provides less
    # lag in game.
    divisions = @temp_bitmap.height / 8
    divisions += 1 if @temp_bitmap.height % 8 != 0
    self.bitmap = Bitmap.new(cw, ch)
    for i in 0..divisions
      x = @wave_amp * Math.sin(i * 2 * PI / (@wave_length / 8).to_i + Math.deg_to_rad(@wave_phase))
      src_rect = Rect.new(0, i*8, @temp_bitmap.width, 8)
      dest_rect = Rect.new(@wave_amp + x, i * 8, @temp_bitmap.width, 8)
      self.bitmap.stretch_blt(dest_rect, @temp_bitmap, src_rect)
    end
    # frame rate: VX = 60 | XP = 40
    # wave speed compatibility VX to XP: wave_speed * 60/40
    # then: wave_speed * 1.5
    @wave_phase += @wave_speed * 1.5 / @wave_length
    @wave_phase -= 360 if @wave_phase > 360
    @wave_phase += 360 if @wave_phase < 0
  end
  
end

#=============#
# module Math #
#=============#
module Math
  
  #-------------------------------
  # Conversion Degree to Radian
  #-------------------------------
  def Math.deg_to_rad(deg)
    return (deg * PI) / 180.0
  end
  
end

Créditos e Agradecimentos
 zecomeia pela versão para XP

C-SIZ(Colméia - Show Item Zelda)

C-SIZ(Colméia - Show Item Zelda)

por zecomeia

Introdução

Mostra um item que foi pego igual/parecido ao jogo Zelda de SNES.

Características

• Mostra a imagem do icone do item que foi pego
• Muda o gráfico do personagem ao pegar o item
• Toca uma SE ao pegar o item
• Pode ser ligado/desligado, até porque aparecer a animação ao pegar qualquer item pode ficar chato dependendo da jogabilidade do seu jogo.

Screen Shot



Como Usar

• Coloque o script acima de main
• Veja no script como configurar e configure
• Faça o charset do personagem ganhando item(siga o exemplo da demo) e nomeio conforme configurado ao colocar na pasta de charsets.
  
• Coloque o arquivo de audio a ser tocado ao pegar o item, na pasta SE e nomeio como configurado no script
• Faça o teste e em caso de dúvida pergunte aqui ou contate sj-pereira@hotmail.com
  

Para ligar/desligar o efeito use "chamar script" em um evento e use os códigos abaixo:

  #  Para ligar:
  $CSIZ = true
  #  Para desligar:
  $CSIZ = nil

Demo

Download da demo

Script

#=============================================
# C-SIZ(Colméia - Show Item Zelda)
#---------------------------------------------
# por zecomeia
# 06/05/2009
# update(11/09/2010)
#- bug da posição da imagem corrigido
#- mudança na forma de ligar/desligar script
#---------------------------------------------
#Descrição: Mostra o item que foi pego igual
#ao jogo Zelda de SNES.
#=============================================

#====================
#   Configuração
#====================

#Ligar/Desligar(true/nil) o efeito de mostrar o item.
$CSIZ = nil #true/nil
#OBS:para liga/desligar a função durante o jogo faça um evento com:
#  Para ligar:
#$CSIZ = true
#  Para desligar:
#$CSIZ = nil
module Config_ItemShowZelda_ZC
  #Nome do arquivo do charset do personagem mostrando que ganhou o item.
  #O nome colocado abaixo tem que ser adicionado ao nome de arquivo
  #do charset original, e não substir sobre o original.
  #Ex: zelda.png -> zelda(show_item_zelda).png
  #OBS:Uma é p charset normal do personagem e a outra é o charset
  #mostrando que ganhou o item.
  GRAPHIC_ARQ_NAME = "(show_item)"
  #Nome do arquivo de SE que é tocado ao ganhar o item.
  SOUND_ARQ_NAME = "LTTP_ItemFanfare"  
end
 
class Window_ItemShow < Window_Base
 
  #--------------------------------------------------------------------------
  # Inicialização dos Objetos
  #
  #     ator : Objeto
  #--------------------------------------------------------------------------
 
  def initialize(x, y, item)
    super(x - 28, y - 88, 64, 72)
    self.contents = Bitmap.new(width - 36, height - 36)
    self.contents.font.name = $fontface
    self.contents.font.size = $fontsize
    @item = item
    refresh
  end
 
  #--------------------------------------------------------------------------
  # Atualizar
  #--------------------------------------------------------------------------
 
  def refresh
    self.contents.clear
    draw_item_name(@item, 0, 0)
  end 

end

class Game_Player < Game_Character
 
#--Inclusão das configurações--
include Config_ItemShowZelda_ZC
#------------------------------
 
  def refresh_gain_object_zelda
    # Se o número de membros no Grupo de Heróis for 0
    if $game_party.actors.size == 0
      # Limpar o nome do arquivo e a tonalidade do Herói
      @character_name = ""
      @character_hue = 0
      # Fim do método
      return
    end
    # Selecionar o Herói líder
    actor = $game_party.actors[0]
    # Selecionar o nome do arquivo e a tonalidade do Herói
    @character_name = actor.character_name + GRAPHIC_ARQ_NAME
    @character_hue = actor.character_hue
    # Inicializar a opacidade e a sinteticidade
    @opacity = 255
    @blend_type = 0
  end
 
  #--------------------------------------------------------------------------
  # Atualização do Frame
  #--------------------------------------------------------------------------
 
  def update
    # Memorizar, se estiver movendo ou não, nas variáveis locais
    last_moving = moving?
    # Se estiver movendo, um evento ocorrendo, uma rota pré-determinada, ou
    # se estiver exibindo uma mensagem
    # Mostrar tudo como se não estivessem ocorrendo
    unless moving? or $game_system.map_interpreter.running? or
           @move_route_forcing or $game_temp.message_window_showing
      # Mover o Jogador na direção que o direcional for pressionado
    if $wait_itemshow_zelda == 0 
       case Input.dir4
       when 2
         move_down
       when 4
         move_left
       when 6
         move_right
       when 8
         move_up
       end
     end
    end
    # Memorizar as coordenadas nas variáveis locais
    last_real_x = @real_x
    last_real_y = @real_y
    super
    # Se o Herói for movido para baixo e tenha ficado abaixo do centro da tela
    if @real_y > last_real_y and @real_y - $game_map.display_y > CENTER_Y
      # Rolar o mapa para baixo
      $game_map.scroll_down(@real_y - last_real_y)
    end
    # Se o Herói for movido para a esquerda e tenha ficado a esquerda do centro
    # da tela
    if @real_x < last_real_x and @real_x - $game_map.display_x < CENTER_X
      # Rolar o mapa para a esquerda
      $game_map.scroll_left(last_real_x - @real_x)
    end
    # Se o Herói for movido para a direita e tenha ficado a direita do centro da
    # tela
    if @real_x > last_real_x and @real_x - $game_map.display_x > CENTER_X
      # Rolar o mapa para a direita
      $game_map.scroll_right(@real_x - last_real_x)
    end
    # Se o Herói for movido para cima e tenha ficado acima do centro da tela
    if @real_y < last_real_y and @real_y - $game_map.display_y < CENTER_Y
      # rolar o mapa para cima
      $game_map.scroll_up(last_real_y - @real_y)
    end
    # Se não estiver movendo
    unless moving?
      # Se o jogador estava se movendo
      if last_moving
        # Se a determinante de incialização for por toque ou mesma posição
        result = check_event_trigger_here([1,2])
        # Se o Evento que foi iniciado não existir
        if result == false
          # Desconsiderar se o Modo de Depuração estiver ON e a tecla Ctrl
          # pressionada
          unless $DEBUG and Input.press?(Input::CTRL)
            # Diminuir 1 do contador de encontros
            if @encounter_count > 0
              @encounter_count -= 1
            end
          end
        end
      end
      # Se o botão C for pressionado
      if Input.trigger?(Input::C)
        # Determinantes de mesma posição e na frente do Evento
        check_event_trigger_here([0])
        check_event_trigger_there([0,1,2])
      end
    end
  end
 
end 

class Game_Party

#--Inclusão das configurações--
include Config_ItemShowZelda_ZC
#------------------------------

  #--------------------------------------------------------------------------
  # Ganhou ou Perder Itens
  #
  #     item_id : iD do Item
  #     n       : quantidade
  #--------------------------------------------------------------------------
 
  def gain_item(item_id, n)
    if $CSIZ == true
     $wait_itemshow_zelda = 80
     $game_player.turn_down
     $game_player.refresh_gain_object_zelda
     Audio.se_play("Audio/SE/" + SOUND_ARQ_NAME, 100, 100)
     $window_itemshow_zelda = Window_ItemShow.new($game_player.screen_x, $game_player.screen_y, $data_items[item_id]) 
     $window_itemshow_zelda.opacity = 0
    end
    # Atualizar a quantidade nesta divisão
    if item_id > 0
      @items[item_id] = [[item_number(item_id) + n, 0].max, 99].min
    end
  end
 
  #--------------------------------------------------------------------------
  # Ganhar ou Perder Armas
  #
  #     weapon_id : ID da Arma
  #     n         : quantidade
  #--------------------------------------------------------------------------
 
  def gain_weapon(weapon_id, n)
    if $CSIZ == true
     $wait_itemshow_zelda = 80
     $game_player.turn_down
     $game_player.refresh_gain_object_zelda
     Audio.se_play("Audio/SE/" + SOUND_ARQ_NAME, 100, 100)
     $window_itemshow_zelda = Window_ItemShow.new($game_player.screen_x, $game_player.screen_y, $data_weapons[weapon_id])
     $window_itemshow_zelda.opacity = 0
    end
    # Atualizar a quantidade nesta divisão
    if weapon_id > 0
      @weapons[weapon_id] = [[weapon_number(weapon_id) + n, 0].max, 99].min
    end
  end
 
  #--------------------------------------------------------------------------
  # Ganhar ou Perder Armaduras
  #
  #     armor_id : ID da Armadura
  #     n        : quantidade
  #--------------------------------------------------------------------------
 
  def gain_armor(armor_id, n)
    if $CSIZ == true
     $wait_itemshow_zelda = 80
     $game_player.turn_down
     $game_player.refresh_gain_object_zelda
     Audio.se_play("Audio/SE/" + SOUND_ARQ_NAME, 100, 100)
     $window_itemshow_zelda = Window_ItemShow.new($game_player.screen_x, $game_player.screen_y, $data_armors[armor_id])
     $window_itemshow_zelda.opacity = 0
    end
    # Atualizar a quantidade nesta divisão
    if armor_id > 0
      @armors[armor_id] = [[armor_number(armor_id) + n, 0].max, 99].min
    end
  end
 
end 

class Scene_Map
 
  alias new_main main
 
  def main
    $wait_itemshow_zelda = 0
    $window_itemshow_zelda = Window_ItemShow.new($game_player.screen_x, $game_player.screen_y, $data_items[0])
    $window_itemshow_zelda.opacity = 0
    new_main
    $window_itemshow_zelda.dispose
  end
 
  alias new_update update
 
  def update
    if $wait_itemshow_zelda > 0
      $game_player.turn_down
      $game_player.refresh_gain_object_zelda
      $window_itemshow_zelda.visible = true
      $wait_itemshow_zelda -= 1
    else
      $window_itemshow_zelda.visible = false
      $game_player.refresh
      $wait_itemshow_zelda = 0
    end 
  new_update
  end

end

Créditos e Agradecimentos
 zecomeia

Scene_Logotipo 1.2

Scene_Logotipo 1.2
por zecomeia

Introdução

Mostra uma imagem com efeito de fade in/out na apresentação do jogo(antes da tela de titulo).

Características

• configuracão da velocidade do efeito de fade;
  
• configuração de uma tecla para pular a introdução caso desejado.
  

Screenshots

Não necessita.

Como usar

Instale o script acima de main e procure a linha a seguir no script de main do seu jogo(provavelmente na linha 31):

  $scene = Scene_Title.new

e então troque por:

  $scene = Scene_Logotipo.new

Mais informações no começo do script.

Demo

Download da demo

Script

#-------------------------------------------------------------
#-------------------Scene_Logotipo----------------------------
#--------------------versão: 1.2 (RMXP)-----------------------
#-------------------------------------------------------------
#-por: zecomeia----------------------
#-19/12/2008--------------------------------------------------
#http://colmeia-do-ze.blogspot.com/
#-------------------------------------------------------------
#-------------------------------------------------------------
#---Mostra uma Logo Marca com efeito Fade, antes do Title-----
#-------------------------------------------------------------
#-Leia as instruções para instalar o script no final do mesmo-
#-------------------------------------------------------------

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

module ConfigIntroScene
#Defina o nome da imagem que será usada.Lembre-se de coloca-la na pasta picture do projeto
  IMAGE_NAME = "logo"
#Defina a velocidade do efeito de fade.Nunca coloque zero 
  SPEED_FADE = 1
#Escolha uma tecla que servirá para pular a introdução.A tecla pode ser:
# Input::LEFT  Input::UP Input::RIGHT Input::DOWN
# Input::SHIFT Input::CTRL Input::ALT
# Input::F5 Input::F6 Input::F7 Input::F8 Input::F9
# Input::A Input::B Input::C Input::X Input::Y Input::Z Input::L Input::R
#OBS:Copie e cole o botão que quiser acima, assim é mais fácil.
#Caso não queira que tenha um botão que pule a intro deixe escrito
# nil
  INPUT_SKIP_INTRO = nil
end 
 
 #--------------------------------------
 #---Definindo a classe Scene_Logotipo--
 #--------------------------------------

class Scene_Logotipo
 
include ConfigIntroScene
 
  #---------------------------
  #--------Main da Classe-----
  #---------------------------
 
  def main
        # Se estiver em Teste de Batalha
    if $BTEST
      battle_test
      return
    end
    # Criação do gráfico da Logo Marca
    $data_system = load_data("Data/System.rxdata")
    $data_system = Game_System.new
    @logo = Sprite.new
    @logo.bitmap = RPG::Cache.picture(IMAGE_NAME)
    @logo.opacity = 0
    @opacity = 0
    # Variavel de troca de Fades
    fade = 0
    # Executa a Transição
    Graphics.transition
    # Loop principal
    loop do
      # Atualiza a tela do jogo
      Graphics.update
      # Atualiza entradas
      Input.update
      # Reconhece se C foi pressionado
      if INPUT_SKIP_INTRO != nil
       update
      end
     
 #--------------------------
 #---Fade In----------------
 #--------------------------
 
  if fade == 0
  @opacity += SPEED_FADE
  @logo.opacity = @opacity
  if @opacity > 255
    fade = 1
    end
 end
 
 #--------------------------
 #---Fade Out---------------
 #--------------------------
 
 if fade == 1 
  @opacity -= SPEED_FADE
  @logo.opacity = @opacity
  if @opacity < 0
     $scene = Scene_Title.new
     end
   end
  # Interrompe os loops de transição de tela
      if $scene != self
        break
      end
    end
    # Prepara a Transição
    Graphics.freeze
    # Dispose
    @logo.dispose
  end
 
  #---------------------------
  #--------Update-------------
  #---------------------------
 
  def update
  # Se apertar a tecla C
    if Input.trigger?(INPUT_SKIP_INTRO)
    # Vai para a Tela de Título
      $scene = Scene_Title.new
    end
  end
 
  #--------------------------------------------------------------------------
  # Teste de Batalha
  #--------------------------------------------------------------------------
 
  def battle_test
    # Carregar Banco de Dados para o Teste de Batalha
    $data_actors        = load_data("Data/BT_Actors.rxdata")
    $data_classes       = load_data("Data/BT_Classes.rxdata")
    $data_skills        = load_data("Data/BT_Skills.rxdata")
    $data_items         = load_data("Data/BT_Items.rxdata")
    $data_weapons       = load_data("Data/BT_Weapons.rxdata")
    $data_armors        = load_data("Data/BT_Armors.rxdata")
    $data_enemies       = load_data("Data/BT_Enemies.rxdata")
    $data_troops        = load_data("Data/BT_Troops.rxdata")
    $data_states        = load_data("Data/BT_States.rxdata")
    $data_animations    = load_data("Data/BT_Animations.rxdata")
    $data_tilesets      = load_data("Data/BT_Tilesets.rxdata")
    $data_common_events = load_data("Data/BT_CommonEvents.rxdata")
    $data_system        = load_data("Data/BT_System.rxdata")
    # Aqui o contador de frames é resetado para que se conte o Tempo de Jogo
    Graphics.frame_count = 0
    # Criar cada tipo de objetos do jogo
    $game_temp          = Game_Temp.new
    $game_system        = Game_System.new
    $game_switches      = Game_Switches.new
    $game_variables     = Game_Variables.new
    $game_self_switches = Game_SelfSwitches.new
    $game_screen        = Game_Screen.new
    $game_actors        = Game_Actors.new
    $game_party         = Game_Party.new
    $game_troop         = Game_Troop.new
    $game_map           = Game_Map.new
    $game_player        = Game_Player.new
    # Configurar Grupo para o Teste de Batalha
    $game_party.setup_battle_test_members
    # Definir o ID do Grupo de Inimigos, a possibilidade de fuga e o Fundo de
    # Batalha
    $game_temp.battle_troop_id = $data_system.test_troop_id
    $game_temp.battle_can_escape = true
    $game_map.battleback_name = $data_system.battleback_name
    # Reproduzri SE de início de batalha
    $game_system.se_play($data_system.battle_start_se)
    # Reproduzir BGM de batalha
    $game_system.bgm_play($game_system.battle_bgm)
    # Mudar para a tela de batalha
    $scene = Scene_Battle.new
  end
end

#------------------------------------------------------------------
#---Instalando o Scene_Logotipo------------------------------------
#------------------------------------------------------------------
#-Apenas cole este script acima de Main.Após feito isso,vá em Main-
#e altere a linha n°32 de "$scene = Scene_Scene_Title.new" para----
#"$scene = Scene_Scene_Logotipo.new".Agore coloque a imagem de sua-
#Logo Marca na pasta system de seu jogo como nome de "logo.png".---
#------------------------------------------------------------------

Créditos e Agradecimentos
Feito por zecomeia 
 

C-CPP(Colméia - Change Party Position)

C-CPP(Colméia - Change Party Position)

por zecomeia

Introdução

Com este script o jogador pode trocar a ordem dos personagens do grupo.

Características

• trocar ordem dos personagens

Screen Shot



Como Usar

• Cole acima de main
• Para chamar o script vá em "chamar script" em um evento e coloque:

$scene = Scene_Ordem.new

Demo

Download da demo

Script

#---------------------------------------------------------------
#- ChangePartyPosition(Menu de Ordem) --------------------------
#- por: zecomeia ------------------------------
#- 18/02/2009 --------------------------------------------------
# Descrição: Essa opção faz com que o jogador tenha a liberdade
#de trocar a posição dos Heróis no grupo. ----------------------
#---------------------------------------------------------------

class Scene_Ordem
 
  def main
    @status_window = Window_MenuStatus.new
    @status_window.x = 72
    @status_window.y = 0
    @stlock_window = Window_MenuStatus.new
    @stlock_window.x = 72
    @stlock_window.y = 0
    @status_window.active = true
    @status_window.index = 0
    @stlock_window.active = true
    @stlock_window.index = 0
    # Criar chaves de controle para escolha dos personagem na troca
    @lock_firstchoice = nil
    @next_choice = nil
    # Executar transição
    Graphics.transition
    # Loop principal
    loop do
      # Atualizar a tela de jogo
      Graphics.update
      # Atualizar a entrada de informações
      Input.update
      # Atualizar Frame
      update
      # Abortar loop se a tela for alterada
      if $scene != self
        break
      end
    end
    # Preparar para transiçõa
    Graphics.freeze
    # Exibição das janelas
    @status_window.dispose
    @stlock_window.dispose
  end
 
  def update
    @status_window.update
    @stlock_window.update
    # Se a janela de Status estiver ativa e: call update_status
    if @status_window.active and @next_choice != true
      update_status
      return
    end
    # Se a segunda escolha da troca de personagens estiver ativa: call comand_ordem
    if @next_choice == true 
      comand_ordem
      return
    end
  end
 
  #-------------------------------------------------------------
  #-- comand_ordem (segunda escolha da troca de posição) -------
  #-------------------------------------------------------------
 
  def comand_ordem
    # Se o botão B for pressionado (Cancel)
    if Input.trigger?(Input::B)
      # Reproduzir SE de cancelamento
      $game_system.se_play($data_system.cancel_se)
      # Voltar para escolha do primeiro Herói da troca
      @stlock_window.active = true
      @stlock_window.index = -1
      @next_choice = false
      @lock_firstchoice = false
      return
    end
    # Se o botão C for pressionado (OK)
    if Input.trigger?(Input::C)
      # Reproduzir SE de OK
      $game_system.se_play($data_system.decision_se)
      # Segunda escolha da troca de Heróis
      if @status_window.index == 0 #Se for o primeiro do grupo
        # Trocar posições dos personagens escolhidos
        @second_choice = $game_party.actors[0]
        $game_party.actors[0] = $game_party.actors[@first_choice]
        $game_party.actors[@first_choice] = @second_choice
        # Manter posição do cursor de escolha
        @indice_position = 0
        # Renovar gráficos
        update_ordem
      elsif @status_window.index == 1 #Se for o segundo do grupo
        # Trocar posições dos personagens escolhidos
        @second_choice = $game_party.actors[1]
        $game_party.actors[1] = $game_party.actors[@first_choice]
        $game_party.actors[@first_choice] = @second_choice
        # Manter posição do cursor de escolha
        @indice_position = 1
        # Renovar gráficos
        update_ordem
      elsif @status_window.index == 2 #Se for o terceiro do grupo
        # Trocar posições dos personagens escolhidos
        @second_choice = $game_party.actors[2]
        $game_party.actors[2] = $game_party.actors[@first_choice]
        $game_party.actors[@first_choice] = @second_choice
        # Manter posição do cursor de escolha
        @indice_position = 2 
        # Renovar gráficos
        update_ordem
      elsif @status_window.index == 3 #Se for o quarto do grupo
        # Trocar posições dos personagens escolhidos
        @second_choice = $game_party.actors[3]
        $game_party.actors[3] = $game_party.actors[@first_choice]
        $game_party.actors[@first_choice] = @second_choice
        # Manter posição do cursor de escolha
        @indice_position = 3
        # Renovar gráficos
        update_ordem
      end       
    end
  end
 
  #-----------------------------------------------------------------------------
  #-- update_ordem (renova os gráficos da janela de status e do lider do grupo -
  #-----------------------------------------------------------------------------
 
  def update_ordem
        $game_player.refresh
        @status_window.dispose
        @stlock_window.dispose
        @status_window = Window_MenuStatus.new
        @stlock_window = Window_MenuStatus.new
        @status_window.x = 72
        @status_window.y = 0
        @stlock_window.x = 72
        @stlock_window.y = 0
        @stlock_window.active = true
        @stlock_window.index = -1
        @status_window.active = true
        @status_window.index = @indice_position
        @next_choice = false
        @lock_firstchoice = false
        return
  end
 
  #--------------------------------------------------------------------------
  # - Atualização do Frame (Quando o status da Janela estiver Ativo)
  #--------------------------------------------------------------------------
 
  def update_status
    # Se o botão B for pressionado
    if Input.trigger?(Input::B)
      # Reproduzir SE de cancelamento
      $game_system.se_play($data_system.cancel_se)
      $scene = Scene_Map.new
      return
    end
    # Se o botão C for pressionado
    if Input.trigger?(Input::C)
        # Reproduzir SE de OK
        $game_system.se_play($data_system.decision_se)
        # Escolha do primeiro personagem da troca
        if @status_window.index == 0 and @lock_firstchoice != true
        @first_choice = 0
        # Travar um cursor de indicação da primeira escolha
        @stlock_window.index = 0
        @lock_firstchoice = true 
        elsif @status_window.index == 1 and @lock_firstchoice != true
        @first_choice = 1
        # Travar um cursor de indicação da primeira escolha
        @stlock_window.index = 1
        @lock_firstchoice = true
        elsif @status_window.index == 2 and @lock_firstchoice != true
        @first_choice = 2
        # Travar um cursor de indicação da primeira escolha
        @stlock_window.index = 2
        @lock_firstchoice = true
        elsif @status_window.index == 3 and @lock_firstchoice != true
        @first_choice = 3
        # Travar um cursor de indicação da primeira escolha
        @stlock_window.index = 3
        @lock_firstchoice = true 
        end       
        # Trava do cursor da primeira escolha
        if @lock_firstchoice == true
        @stlock_window.active = false
        # Iniciar escolha do segundo personagem na troca
        @next_choice = true
        end
      end
      return
    end
  end

Créditos e Agradecimentos
 zecomeia

Horror_Menu 2.0

Horror_Menu 2.0
por zecomeia
design aero

Introdução

Scene de Title por imagens com sistema de creditos e extras.O sistema
de creditos e extras simplesmente salva duas variáveis  junto ao arquivo
de save e lê todos os arquivos quando o jogo é executado e se essa(as) variaveis
estiverem ligadas liberam sua opção.Existem algumas configurações no script.

Características

• Scene de titulo toda por imagens;
  
• Sistema de extras e creditos;
  

Screenshots



Como usar

Coloque o script acima de main.

Outras instruções no próprio script e na demo.

Demo

Download da demo

Script

#================================================================
#             Horror_Menu 2.0
#----------------------------------------------------------------
# por: zecomeia
# data: 13/04/2009
#http://colmeia-do-ze.blogspot.com/
# Desgin por Aero
=begin
Explicação:
O sistema de extras e creditos que vem com este menu é uito simples de usar.
Você pode, por exemplo, abilitar só a opção de extras ou de creditos ou ambas
quando chegar em determinada parte do jogo, ou ate mesmo quando
acabar o jogo para liberar mini-games, curiosidades, etc.A parte
do script fixada no menu lê todos os arquivos de saves para ver se estão
ativadas as variavéis que abilitam a opção de extras e/ou creditos.
Mas para todo esse sistema funcionar precisa saber utilizar a intrução abaixo:

1º No evento em que irá ativar estas opções para o jogador, use o comando
"chamar script" do menu de eventos e coloque o script abaixo:

$extras_enabled = true #true = abilitar extras - false = desabilitar extras
$credits_enabled = true #true = abilitar creditos - false = desabilitar creditos
save_infos = Scene_Save.new
save_infos.save_extras

2º Pronto, não precisa de mais nada.Desta forma são definidos os valores
e já são salvos automaticamente.

Mas existe a possibilidade de apenas definir o valor e deixe que só sejam salvos
quando o jogador salvar o jogo.Para isso basta:

1º No evento em que irá ativar estas opções para o jogador, use o comando
"chamar script" do menu de eventos e coloque o script abaixo:

$extras_enabled = true #true = abilitar extras - false = desabilitar extras
$credits_enabled = true #true = abilitar creditos - false = desabilitar creditos

2º Pronto.Desta forma os valores foram definidos e só serão salvos quando
o jogador o fizer(salvar).


Dúvidas visite o Site  www.santuariorpgmaker.com/forum
e procure por zecomeia

=end
#================================================================

#================================================================
#CONFIGURAÇÕES
#================================================================
module ConfigExtrasData
 # Informações do mapa para opção "Creditos",respectivamente
 #"ID do mapa", "Posição inicial X do heroi","Posição inicial Y do heroi"
 MapaCredId = 2
 MapaCredX = 5
 MapaCredY = 5
 # Informações do mapa para opção "Extras",respectivamente
 #"ID do mapa", "Posição inicial X do heroi","Posição inicial Y do heroi"
 MapaExtId = 3
 MapaExtX = 6
 MapaExtY = 6
 #Se por algum motivo não quiser usar o sistema de extras e creditos
 # acionaveis no jogo então coloque o valor como true nas variaveis
 #abaixo, em qual decidir
 CREDITS_ENABLE = false #ou true
 EXTRAS_ENABLE = false #ou true
end
#=====FIM========================================================

#==============================================================================
# Scene_Title
#------------------------------------------------------------------------------
# Esta classe trata da Tela de Título
#==============================================================================

class Scene_Title
 
  include ConfigExtrasData
 
  #--------------------------------------------------------------------------
  # Processamento Principal
  #--------------------------------------------------------------------------
 
  def main
    # Se estiver em Teste de Batalha
    if $BTEST
      battle_test
      return
    end
    # Carregar o Banco de Dados
    $data_actors        = load_data("Data/Actors.rxdata")
    $data_classes       = load_data("Data/Classes.rxdata")
    $data_skills        = load_data("Data/Skills.rxdata")
    $data_items         = load_data("Data/Items.rxdata")
    $data_weapons       = load_data("Data/Weapons.rxdata")
    $data_armors        = load_data("Data/Armors.rxdata")
    $data_enemies       = load_data("Data/Enemies.rxdata")
    $data_troops        = load_data("Data/Troops.rxdata")
    $data_states        = load_data("Data/States.rxdata")
    $data_animations    = load_data("Data/Animations.rxdata")
    $data_tilesets      = load_data("Data/Tilesets.rxdata")
    $data_common_events = load_data("Data/CommonEvents.rxdata")
    $data_system        = load_data("Data/System.rxdata")
    # Criar um Sistema
    $game_system = Game_System.new
    # Verificação de creditos e extras
    ext_on = false
    cre_on = false
    verify = Scene_Load.new
    $extras_enabled = false
    $credits_enabled = false
    for i in 0..3
     if FileTest.exist?("Save#{i+1}.rxdata")
       filename = "Save#{i+1}.rxdata"
       file = File.open(filename, "r")
       verify.read_extras_data(file)
       if $extras_enabled == true or ext_on == true
         ext_on = true
         $extras_enabled = true
       end
       if $credits_enabled == true or cre_on == true
         cre_on = true
         $credits_enabled = true
       end
       file.close
       ext_on = false
       cre_on = false
     end
    end
    if $extras_enabled == nil
      $extras_enabled = false
    end
    if $credits_enabled == nil
      $credits_enabled = false
    end
    # Informações para efeito de confirmação
    @oy = 1
    @z_x = 1
    @z_y = 1
    @a = false
    @x = 0
    @y = 0
    #######
    # Informações do mapa para opção "Creditos",respectivamente
    #"ID do mapa", "Posição inicial X do heroi","Posição inicial Y do heroi"
    #***Configure no modulo no inicio do script
    @mapa_creditos = MapaCredId
    @mapa_creditos_x = MapaCredX
    @mapa_creditos_y = MapaCredY
    # Informações do mapa para opção "Extras",respectivamente
    #"ID do mapa", "Posição inicial X do heroi","Posição inicial Y do heroi"
    #***Configure no modulo no inicio do script 
    @mapa_extras = MapaExtId
    @mapa_extras_x = MapaExtX
    @mapa_extras_y = MapaExtY
    #
    #
    if CREDITS_ENABLE == true
      $credits_enabled = true
    end 
    if EXTRAS_ENABLE == true
      $extras_enabled = true
    end 
    #######
    # Posição inicial do cursor
    @indice = 1
    # Abilitação das setas de controle(cima/baixo)
    @enable_cursor = true
    # Estado dos comandos de efeito da troca de opções
    @down_command = false
    @up_command = false
    # Variaveis que definem a ordem inicial do cursor de opções,
    #e que são redefinidas ao lono do script para o funcionamento do script
    # Caso não saiba nada de programção não tente alterar estes valores,
    #porque precisam ser alterados em outros pontos
    @back = "sair"
    @main = "novo jogo"
    @near = "carregar"
    # Criar um Sistema
    $game_system = Game_System.new
    # Graficos do sistema do menu de titulo
    @back_option = Sprite.new
    @main_option = Sprite.new
    @near_option = Sprite.new
    @background = Sprite.new
    grafics
    @background.x  = 1
    @background.oy = 1
    # Aqui é checado se existe algum arquivo de save
    # Se estiver habilitado, tornar @continue_enabled verdadeiro; se estiver
    # desabilitado, tornar falso
    $continue_enabled = false
    for i in 0..3
      if FileTest.exist?("Save#{i+1}.rxdata")
        $continue_enabled = true
      end
    end
    # Ativa(true)/Desativa(false) a opção de creditos no menu de titulo
    #$credits_enabled = true
    # Ativa(true)/Desativa(false) a opção de extras no menu de titulo
    #$extras_enabled = true
    #OBS:Mesmo desativada a opção continua la, só que com  uma opacidade menor
    #para indicar que está desativada, e sua função também não funciona.
    ##########################
    # Reproduzir BGM de Título
    $game_system.bgm_play($data_system.title_bgm)
    # Parar de reproduzir BGS e ME
    Audio.me_stop
    Audio.bgs_stop
    # Executar transição
    Graphics.transition
    # Loop principal
    loop do
      # Atualizar a tela de jogo
      Graphics.update
      # Atualizar a entrada de informações
      Input.update
      # Atualizar o frame
      update
      # Abortar o loop caso a tela tenha sido alterada
      if $scene != self
        break
      end
    end
    # Preparar para transição
    Graphics.freeze
    # Exibir a janela de comandos
    @back_option.dispose
    @main_option.dispose
    @near_option.dispose
    # Exibir o gráfico de Título
    @background.bitmap.dispose
    @background.dispose
  end
 
  #----------------------------------------------------
  #-- grafics(define e atualiza os graficos do menu) --
  #----------------------------------------------------
 
  def grafics
    back = @back
    main = @main
    near = @near
    @back_option.bitmap = RPG::Cache.picture(back.to_s)
    @back_option.x = 50
    @back_option.y = 155
    @main_option.bitmap = RPG::Cache.picture(main.to_s)
    @main_option.x = 50
    @main_option.y = 207
    @near_option.bitmap = RPG::Cache.picture(near.to_s)
    @near_option.x = 50
    @near_option.y = 259
    @background.bitmap = RPG::Cache.picture("backgrund")
  end
 
  #--------------------------------------------------------------
  #-- indice_updt(atualiza os graficos das opções e sua ordem) --
  #--------------------------------------------------------------
 
  def indice_updt
    # Atualizar a janela de comandos
    case @indice
    when 1
    @back = "sair"
    @main = "novo jogo"
    @near = "carregar"
    grafics
    when 2
    @back = "novo jogo"
    @main = "carregar"
    @near = "extras"
    grafics
    when 3
    @back = "carregar"
    @main = "extras"
    @near = "creditos"
    grafics
    when 4
    @back = "extras"
    @main = "creditos"
    @near = "sair"
    grafics
    when 5
    @back = "creditos"
    @main = "sair"
    @near = "novo jogo"
    grafics
    end
    # Atualiza os gráficos das opções no frame
    @back_option.update
    @main_option.update
    @near_option.update
  end
 
  #--------------------------------------------------------------------------
  # Atualização do Frame
  #--------------------------------------------------------------------------
 
  def update
    if @zoom_effect == true
       @back_option.x = -100
       @near_option.x = -100
       @x -= 20
       @background.x = @x
       @y -= 80
       @background.y = @y
       @z_x += 0.0164 * 20
       @background.zoom_x = @z_x
       @z_y += 0.0164 * 20
       @background.zoom_y = @z_y
       @background.opacity -= 15
       @main_option.zoom_x += 0.0164 * 20
       @main_option.zoom_y += 0.0164 * 20
       @main_option.x -= 4
       @main_option.y -= 12
       if @background.zoom_x >= 0.0164 * 500
       @a = true
        if @novo_conf == true
         command_new_game
        elsif @continue_conf == true
         command_continue
        elsif @credito_conf == true
         command_creditos
        elsif @extra_conf == true
         command_extras
        elsif @sair_conf == true
         command_shutdown
        end
       end
    end
    ########Inicio###################
    # Comandos de efeito de deslocamento das imagens de opções
    if @down_command == true
     @back_option.y += 3
     @main_option.y += 3
     if @back_option.y > 206 and @main_option.y > 258
     @indice -= 1
     if @indice < 1
        @indice = 5
     end
     @down_command = false
     @enable_cursor = true
     indice_updt
     end
    end
    if @up_command == true
     @near_option.y -= 3
     @main_option.y -= 3
     if @near_option.y < 208 and @main_option.y < 156     
     @indice += 1
     if @indice > 5
        @indice = 1
     end
     @up_command = false
     @enable_cursor = true
     indice_updt
     end
    end
    #########Fim############
    ############Inicio########################
    # Reconhecimento de opção ativada/desativada para "Carregar","Extras","Creditos"
    # Se estiver desabilitado o texto será mostrado em cinza
case @indice
when 1
    @back_option.opacity = 255
    @main_option.opacity = 255
    @near_option.opacity = 255
    if $continue_enabled == false
      @near_option.opacity = 100
    end
when 2 #########################
    if $continue_enabled == false && $extras_enabled == false && $credits_enabled == false
    @back_option.opacity = 255
    @main_option.opacity = 100
    @near_option.opacity = 100
elsif $continue_enabled == false && $extras_enabled == false && $credits_enabled == true   
    @back_option.opacity = 255
    @main_option.opacity = 100
    @near_option.opacity = 100
elsif $continue_enabled == false && $extras_enabled == true && $credits_enabled == false
    @back_option.opacity = 255
    @main_option.opacity = 100
    @near_option.opacity = 255 
elsif $continue_enabled == false && $extras_enabled == true && $credits_enabled == true
    @back_option.opacity = 255
    @main_option.opacity = 100
    @near_option.opacity = 255
elsif $continue_enabled == true && $extras_enabled == false && $credits_enabled == false
    @back_option.opacity = 255
    @main_option.opacity = 255
    @near_option.opacity = 100 
elsif $continue_enabled == true && $extras_enabled == false && $credits_enabled == true
    @back_option.opacity = 255
    @main_option.opacity = 255
    @near_option.opacity = 100
elsif $continue_enabled == true && $extras_enabled == true && $credits_enabled == false
    @back_option.opacity = 255
    @main_option.opacity = 255
    @near_option.opacity = 255 
elsif $continue_enabled == true && $extras_enabled == true && $credits_enabled == true 
    @back_option.opacity = 255
    @main_option.opacity = 255
    @near_option.opacity = 255
   end
when 3 #########################
    if $continue_enabled == false && $extras_enabled == false && $credits_enabled == false
    @back_option.opacity = 100
    @main_option.opacity = 100
    @near_option.opacity = 100
elsif $continue_enabled == false && $extras_enabled == false && $credits_enabled == true   
    @back_option.opacity = 100
    @main_option.opacity = 100
    @near_option.opacity = 255
elsif $continue_enabled == false && $extras_enabled == true && $credits_enabled == false
    @back_option.opacity = 100
    @main_option.opacity = 255
    @near_option.opacity = 100 
elsif $continue_enabled == false && $extras_enabled == true && $credits_enabled == true
    @back_option.opacity = 100
    @main_option.opacity = 255
    @near_option.opacity = 255
elsif $continue_enabled == true && $extras_enabled == false && $credits_enabled == false
    @back_option.opacity = 255
    @main_option.opacity = 100
    @near_option.opacity = 100 
elsif $continue_enabled == true && $extras_enabled == false && $credits_enabled == true
    @back_option.opacity = 255
    @main_option.opacity = 100
    @near_option.opacity = 255
elsif $continue_enabled == true && $extras_enabled == true && $credits_enabled == false
    @back_option.opacity = 255
    @main_option.opacity = 255
    @near_option.opacity = 100 
elsif $continue_enabled == true && $extras_enabled == true && $credits_enabled == true 
    @back_option.opacity = 255
    @main_option.opacity = 255
    @near_option.opacity = 255
   end
when 4 ###########################
    if $continue_enabled == false && $extras_enabled == false && $credits_enabled == false
    @back_option.opacity = 100
    @main_option.opacity = 100
    @near_option.opacity = 255
elsif $continue_enabled == false && $extras_enabled == false && $credits_enabled == true   
    @back_option.opacity = 100
    @main_option.opacity = 255
    @near_option.opacity = 255
elsif $continue_enabled == false && $extras_enabled == true && $credits_enabled == false
    @back_option.opacity = 255
    @main_option.opacity = 100
    @near_option.opacity = 255 
elsif $continue_enabled == false && $extras_enabled == true && $credits_enabled == true
    @back_option.opacity = 255
    @main_option.opacity = 255
    @near_option.opacity = 255
elsif $continue_enabled == true && $extras_enabled == false && $credits_enabled == false
    @back_option.opacity = 100
    @main_option.opacity = 100
    @near_option.opacity = 255 
elsif $continue_enabled == true && $extras_enabled == false && $credits_enabled == true
    @back_option.opacity = 100
    @main_option.opacity = 255
    @near_option.opacity = 255
elsif $continue_enabled == true && $extras_enabled == true && $credits_enabled == false
    @back_option.opacity = 255
    @main_option.opacity = 100
    @near_option.opacity = 255 
elsif $continue_enabled == true && $extras_enabled == true && $credits_enabled == true 
    @back_option.opacity = 255
    @main_option.opacity = 255
    @near_option.opacity = 255
   end
when 5
    @back_option.opacity = 255
    if $credits_enabled == false
      @back_option.opacity = 100
    end 
    @main_option.opacity = 255
    @near_option.opacity = 255
end  ######################

    ##############Fim####################
    # Se o botão C for pressionado
    if Input.trigger?(Input::C) and @enable_cursor == true
      # ramificação pela posição do cursor
      case @indice
      when 1  # Novo Jogo
        command_new_game
      when 2  # Carregar
        command_continue
      when 3  # Extras
        command_extras
      when 4  # Creditos
        command_creditos
      #when 5  # Son
       # command_son
      when 5  # Sair
        command_shutdown
      end
    end
    # Se o botão Down for pressionado
    if Input.trigger?(Input::DOWN) and @enable_cursor == true
      # Som de deslocamento do cursor (definida na linha abaixo, e não no database)
      Audio.se_play("Audio/SE/" + "039-Switch08", 100, 100)
      @down_command = true #Iniciar efeito de deslocamento das imagens das opções
      @enable_cursor = false #travar movimento de escolha
    end 
    # Se o botão Up for pressionado
    if Input.trigger?(Input::UP) and @enable_cursor == true
      # Som de deslocamento do cursor (definida na linha abaixo, e não no database)
      Audio.se_play("Audio/SE/" + "039-Switch08", 100, 100)
      @up_command = true  #Iniciar efeito de deslocamento das imagens das opções
      @enable_cursor = false #travar movimento de escolha
    end
  end
 

 
  #--------------------------------------------------------------------------
  # Comando: Novo Jogo
  #--------------------------------------------------------------------------
 
  def command_new_game
    if @a == false
    # Reproduzir SE de OK (definida na linha abaixo, e não no database)
    Audio.se_play("Audio/SE/" + "034-Switch03", 100, 100)
    # Parar BGM
    Audio.bgm_stop
    @zoom_effect = true
    @enable_cursor = false
    @novo_conf = true
    end
    if @a == true
    # Aqui o contador de frames é resetado para que se conte o Tempo de Jogo
    Graphics.frame_count = 0
    # Criar cada tipo de objetos do jogo
    $game_temp          = Game_Temp.new
    $game_system        = Game_System.new
    $game_switches      = Game_Switches.new
    $game_variables     = Game_Variables.new
    $game_self_switches = Game_SelfSwitches.new
    $game_screen        = Game_Screen.new
    $game_actors        = Game_Actors.new
    $game_party         = Game_Party.new
    $game_troop         = Game_Troop.new
    $game_map           = Game_Map.new
    $game_player        = Game_Player.new
    # Configurar Grupo Inicial
    $game_party.setup_starting_members
    # Configurar posição inicial no mapa
    $game_map.setup($data_system.start_map_id)
    # Aqui o Jogador é movido até a posição inical configurada
    $game_player.moveto($data_system.start_x, $data_system.start_y)
    # Atualizar Jogador
    $game_player.refresh
    # Rodar, de acordo com o mapa, a BGM e a BGS
    $game_map.autoplay
    # Atualizar mapa (executar processos paralelos)
    $game_map.update
    # Mudar para a tela do mapa
    $scene = Scene_Map.new
    @zoom_effect = false
    end
  end
  #--------------------------------------------------------------------------
  # Comando: Continuar
  #--------------------------------------------------------------------------
 
  def command_continue
    # Se Continuar estiver desabilitado
    unless $continue_enabled
      # Reproduzir SE de erro (definida na linha abaixo, e não no database)
       Audio.se_play("Audio/SE/" + "138-Darkness01", 100, 100)
      return
    end
    if @a == false
    # Reproduzir SE de OK (definida na linha abaixo, e não no database)
    Audio.se_play("Audio/SE/" + "034-Switch03", 100, 100)
    @zoom_effect = true
    @enable_cursor = false
    @continue_conf = true
    end
    if @a == true
    # Mudar para a tela de Carregar arquivos
    $scene = Scene_Load.new
    @zoom_effect = false
    end
  end
 
  #--------------------------------------------------------------------------
  # Comando: Extras
  #--------------------------------------------------------------------------
   
  def command_extras# Se Creditos estiver desabilitado
    unless $extras_enabled
      # Reproduzir SE de erro (definida na linha abaixo, e não no database)
      Audio.se_play("Audio/SE/" + "138-Darkness01", 100, 100)
      return
    end
    if @a == false
    # Reproduzir SE de OK (definida na linha abaixo, e não no database)
    Audio.se_play("Audio/SE/" + "034-Switch03", 100, 100)
    # Parar BGM
    Audio.bgm_stop
    @zoom_effect = true
    @enable_cursor = false
    @extra_conf = true
    end
    if @a == true
    # Aqui o contador de frames é resetado para que se conte o Tempo de Jogo
    Graphics.frame_count = 0
    # Criar cada tipo de objetos do jogo
    $game_temp          = Game_Temp.new
    $game_system        = Game_System.new
    $game_switches      = Game_Switches.new
    $game_variables     = Game_Variables.new
    $game_self_switches = Game_SelfSwitches.new
    $game_screen        = Game_Screen.new
    $game_actors        = Game_Actors.new
    $game_party         = Game_Party.new
    $game_troop         = Game_Troop.new
    $game_map           = Game_Map.new
    $game_player        = Game_Player.new
    # Configurar Grupo Inicial
    $game_party.setup_starting_members
    # Configurar posição inicial no mapa
    $game_map.setup(@mapa_extras)
    # Aqui o Jogador é movido até a posição inical configurada
    $game_player.moveto(@mapa_extras_x , @mapa_extras_y)
    # Atualizar Jogador
    $game_player.refresh
    # Rodar, de acordo com o mapa, a BGM e a BGS
    $game_map.autoplay
    # Atualizar mapa (executar processos paralelos)
    $game_map.update
    # Mudar para a tela do mapa
    $scene = Scene_Map.new
    @zoom_effect = false
    end
end
 
  #--------------------------------------------------------------------------
  # Comando: Creditos
  #--------------------------------------------------------------------------
 
  def command_creditos
    # Se Creditos estiver desabilitado
    unless $credits_enabled
      # Reproduzir SE de erro (definida na linha abaixo, e não no database)
      Audio.se_play("Audio/SE/" + "138-Darkness01", 100, 100)
      return
    end
    if @a == false
    # Reproduzir SE de OK (definida na linha abaixo, e não no database)
    Audio.se_play("Audio/SE/" + "034-Switch03", 100, 100)
    # Parar BGM
    Audio.bgm_stop
    @zoom_effect = true
    @enable_cursor = false
    @credito_conf = true
    end
    if @a == true
    # Aqui o contador de frames é resetado para que se conte o Tempo de Jogo
    Graphics.frame_count = 0
    # Criar cada tipo de objetos do jogo
    $game_temp          = Game_Temp.new
    $game_system        = Game_System.new
    $game_switches      = Game_Switches.new
    $game_variables     = Game_Variables.new
    $game_self_switches = Game_SelfSwitches.new
    $game_screen        = Game_Screen.new
    $game_actors        = Game_Actors.new
    $game_party         = Game_Party.new
    $game_troop         = Game_Troop.new
    $game_map           = Game_Map.new
    $game_player        = Game_Player.new
    # Configurar Grupo Inicial
    $game_party.setup_starting_members
    # Configurar posição inicial no mapa
    $game_map.setup(@mapa_creditos)
    # Aqui o Jogador é movido até a posição inical configurada
    $game_player.moveto(@mapa_creditos_x , @mapa_creditos_y)
    # Atualizar Jogador
    $game_player.refresh
    # Rodar, de acordo com o mapa, a BGM e a BGS
    $game_map.autoplay
    # Atualizar mapa (executar processos paralelos)
    $game_map.update
    # Mudar para a tela do mapa
    $scene = Scene_Map.new
    @zoom_effect = false
    end
  end

  #--------------------------------------------------------------------------
  # Comando: Sair
  #--------------------------------------------------------------------------
 
  def command_shutdown
    if @a == false
    # Reproduzir SE de OK (definida na linha abaixo, e não no database)
    Audio.se_play("Audio/SE/" + "034-Switch03", 100, 100)
    @zoom_effect = true
    @enable_cursor = false
    @sair_conf = true
    end
    if @a == true
    # Diminuir o volume de BGM, BGS e ME
    Audio.bgm_fade(800)
    Audio.bgs_fade(800)
    Audio.me_fade(800)
    # Sair
    $scene = nil
    @zoom_effect = false
    end
  end
 
  #--------------------------------------------------------------------------
  # Teste de Batalha
  #--------------------------------------------------------------------------
 
  def battle_test
    # Carregar Banco de Dados para o Teste de Batalha
    $data_actors        = load_data("Data/BT_Actors.rxdata")
    $data_classes       = load_data("Data/BT_Classes.rxdata")
    $data_skills        = load_data("Data/BT_Skills.rxdata")
    $data_items         = load_data("Data/BT_Items.rxdata")
    $data_weapons       = load_data("Data/BT_Weapons.rxdata")
    $data_armors        = load_data("Data/BT_Armors.rxdata")
    $data_enemies       = load_data("Data/BT_Enemies.rxdata")
    $data_troops        = load_data("Data/BT_Troops.rxdata")
    $data_states        = load_data("Data/BT_States.rxdata")
    $data_animations    = load_data("Data/BT_Animations.rxdata")
    $data_tilesets      = load_data("Data/BT_Tilesets.rxdata")
    $data_common_events = load_data("Data/BT_CommonEvents.rxdata")
    $data_system        = load_data("Data/BT_System.rxdata")
    # Aqui o contador de frames é resetado para que se conte o Tempo de Jogo
    Graphics.frame_count = 0
    # Criar cada tipo de objetos do jogo
    $game_temp          = Game_Temp.new
    $game_system        = Game_System.new
    $game_switches      = Game_Switches.new
    $game_variables     = Game_Variables.new
    $game_self_switches = Game_SelfSwitches.new
    $game_screen        = Game_Screen.new
    $game_actors        = Game_Actors.new
    $game_party         = Game_Party.new
    $game_troop         = Game_Troop.new
    $game_map           = Game_Map.new
    $game_player        = Game_Player.new
    # Configurar Grupo para o Teste de Batalha
    $game_party.setup_battle_test_members
    # Definir o ID do Grupo de Inimigos, a possibilidade de fuga e o Fundo de
    # Batalha
    $game_temp.battle_troop_id = $data_system.test_troop_id
    $game_temp.battle_can_escape = true
    $game_map.battleback_name = $data_system.battleback_name
    # Reproduzri SE de início de batalha
    $game_system.se_play($data_system.battle_start_se)
    # Reproduzir BGM de batalha
    $game_system.bgm_play($game_system.battle_bgm)
    # Mudar para a tela de batalha
    $scene = Scene_Battle.new
  end
end

#################################################################
#################################################################
#################################################################
#################################################################

#===========================================
# Scene_Save e Scene_Load (editado)
#-------------------------------------------
# edição por: zecomeia
# 13/04/2009
# agradecimentos: br_lemes
#-------------------------------------------
# Comentario:este é um script bem especifico
# portanto tendo mais utilidade para estudo
# ou simplesmente para utilizar o menu que
# o acompanha.
#-------------------------------------------
# descrição: Adicionado duas variaveis
#globais ao arquivo de Save, com o objetivo
#de utiliza-las para habilitar Extras no
#jogo.
#===========================================
=begin
Variaveis adicionadas ao save
$extras_enabled   
$credits_enabled

Os metodos acresentados são os seguintes, e com suas respectivas
funções:

class Scene_Save

save_extras 
#este metodo ao ser chamado pela classe Scene_Save, grava as
informações que já são salvadas normalmentes pelo save original
e mais a informação das duas variaveis globais citadas, lembrando
que usando este metodo será salvado o arquivo por cima do ultimo
arquivo escolhido(caso não tenha escolhido nenhum salvará por cima
primeiro).

write_save_data(file)
#na verdade esse metodo ja existe na classe de Scene_Save, mas
foi acrescentada a informação das duas variaveis globais citadas

class Scene_Load

read_extras_data(file)
#este metodo foi feito apenas para não necessitar editar o metodo
read_save_data(file) original, isso para manter o metodo original
da classe Scene_Load com suas caracteristicas intaquitas dando
a possibilidade do usuario escolher quando quer que seja lidas as
informações das duas variaveis globais adicionais ao inves de ser
resgatado o valor de ambas a todo comando de Load.
 
=end

class Scene_Save < Scene_File
 
  #--------------------------------------------------------------------------
  # Gravando
  #     file : Gravando um arquivo
  #--------------------------------------------------------------------------
 
  alias copy_write_save_data write_save_data
  def write_save_data(file)
    copy_write_save_data(file)
    Marshal.dump($extras_enabled, file)
    Marshal.dump($credits_enabled, file)
  end
 
  def save_extras()
    @file_index = $game_temp.last_file_index
    filename = make_filename(@file_index)
    file = File.open(filename, "wb")
    write_save_data(file)
    file.close
  end
 
end

class Scene_Load < Scene_File
 
  #--------------------------------------------------------------------------
  # Ler Dados do Arquivo
  #     file : arquivo que será lido (aberto)
  #--------------------------------------------------------------------------
 
  def read_extras_data(file)
    read_save_data(file)
    $extras_enabled = Marshal.load(file)
    $credits_enabled = Marshal.load(file)
  end
 
end

Créditos e Agradecimentos

• Feito por zecomeia
• Desenhado por aero
• Ajuda indireta de br_lemes

C-SS(Colméia - Skill System)

C-SS(Colméia - Skill System)
por zecomeia

Introdução

É um sistema onde as habilidades tem level como em jogos como Diablo, Ragnarok, e outros MMORPGs.

Características

• Habilidades com level;
• SkillTree;
• Pontos para escolher em quais magias distribuir;
• Habilidades divididas em passivas, ofensivas e com armas
• 15 configurações;

Screenshots
Menu da SkillTree:


Como usar

Coloque o script acima de main.

Para acessar o menu da SkillTree entre no menu de habilidades e aperte 'A'

Intruções sobre o script na demo e no próprio script.

Demo

Download da demo

Script 

#=============================================================
# Sistema de Habilidades Colméia(SHC)
# versão: 1.0
#-------------------------------------------------------------
# por zecomeia
# 14/07/2009
# http://colmeia-do-ze.blogspot.com/
#-------------------------------------------------------------
#Este script cria uma árvore de habilidades que podem aumentar
#de nível conforme distribuidos os "skill points".E outras
#habilidades vão sendo habilitadas conforme as habilidades
#anteriores atingirem um certo nível definido.
#Nesta Skill Tree as habilidades são divididas em 3 tipos:
#    "Habilidades Passivas"
#    "Habilidades Ofensivas"
#    "Habilidades com Armas"
#OBS:Esses nomes podem ser mudados.
#=============================================================

#Coloque acima de main

#Veja as configurações abaixo para aproveitar ao máximo suas funções.

#=================================
# Configurações
#=================================

#-----------------------------
# Configuração ZC_SkillPoints
#-----------------------------

module ZC_SKP
 #Definição da Tecla de informações no menu Skill_Tree.
 #Escolha uma entre:
 #Input::X  Input::A  Input::B  Input::C  Input::Y
 #Input::Z  Input::L  Input::R  nil
 #
 #*Se definir como nil então esta função é desligada
 #OBS:segue o padrão descrito no Help do RPGMaker.
 MORE_INFO_KEY = Input::X
 #-----------------------------------------------------
 
 #Definição do nome do menu Skill_Tree.
 NAME_SKILLTREE = "Árvore de Habilidades"
 #-----------------------------------------------------
 
 #Definição do nome dos 3 tipos de habilidades.Siga a Ordem.
 NAME_SKILLTYPE = [
 "Habilidades Passivas",
 "Habilidades Ofensivas",
 "Habilidades com Armas",
 ]
 #----------------------------------------------------------
 
 #Definição do nome dos Skill_Points.
 SKP_NAME = "SKP"
 #----------------------------------
 
 #Definição da quantidade inicial de SKP(skill points).
 #(Caso não especificado SKP inicial igual a 0)
 #
 #A=>B
 #
 #A = ID do personagem.
 #B = Quantidade inicial de SKP.
 INI_SKP = {
 1=>1,
 2=>5,
 3=>3,
 4=>1,
 5=>2
 }
 #-----------------------------------------------------
 
 #Definição da quantidade de SKP(skill points) ganho
 #quando o personagem subir o level.
 #(Caso não especificado SKP ganho igual a 1)
 #
 #A=>B
 #
 #A = ID do personagem.
 #B = Quantidade de SKP ganho.
 SKP_EXP = {
 1=>2,
 2=>1,
 3=>1,
 4=>3
 }
 #--------------------------------------------------
 
 #Itens que dão SKP.
 #A=>B
 #
 #A = ID do Item
 #B = Quantidade de SKP ganho.
 ITEM_SKP_INCREASE = {
 30=>1,
 31=>1
 }   
 #----------------------------
 
 #Level inicial das habilidades de cada personagem.
 #
 #INI_SKILL_LV[A] = {B=>C, B=>C, ...}
 #
 #A = ID do Personagem
 #B = ID da SKILL.
 #C = Level inicial.
 #*OBS: No database é necessário que coloque para os personagens
 #começarem com todas as habilidades que deseja que cada um tenha,
 #assim elas aparecerão no menu de skilltree.
 #*OBS: Se não foi definido o nível inicial da magia aqui, então
 #ela iniciará no level 0(zero), isso significa que ainda não foi
 #aprendida e portanto não pode ser usada.
 INI_SKILL_LV = []
 INI_SKILL_LV[1] = {
 2=>1,
 7=>1,
 70=>1
 }
 INI_SKILL_LV[2] = {
 1=>3,
 8=>1
 }
 INI_SKILL_LV[3] = {
 9=>4,
 19=>6,
 21=>2,
 53=>9
 }
 INI_SKILL_LV[4] = {
 22=>2,
 25=>2,
 39=>1,
 60=>4
 }
 INI_SKILL_LV[5] = {
 73=>5,
 74=>1,
 75=>4,
 76=>6
 }
 #------------------------------------------------------------------     

 #Level inicial das habilidades de cada personagem.
 #
 #MAX_SKILL_LV[A] = {B=>C, B=>C, ...}
 #
 #A = ID do Personagem
 #B = ID da SKILL.
 #C = Level máximo.
 #*OBS: Se não foi definido o nível máximo da magia aqui, então
 #será definido como 10.
 MAX_SKILL_LV = []
 MAX_SKILL_LV[1] = {
 2=>5,
 7=>6,
 9=>5,
 70=>8,
 72=>9
 }
 MAX_SKILL_LV[2] = {
 1=>7,
 8=>7,
 13=>8,
 63=>8,
 64=>9
 }
 MAX_SKILL_LV[3] = {
 9=>5,
 19=>11,
 21=>15,
 53=>20
 }
 MAX_SKILL_LV[4] = {
 22=>5,
 25=>5,
 39=>5,
 60=>5,
 61=>5
 }
 MAX_SKILL_LV[5] = {
 24=>11,
 73=>11,
 74=>11,
 75=>15,
 76=>11
 }
 #------------------------------------------------------------------     
 
 #Atributos acrescentados/retirados das habilidades por skill level evoluído.
 #
 #ATRIBUTE_SKILLS[A] = {B=>[C, D, E, F, G, H, I, J, K, L, M, N], B=>[C, D, E, F, G, H, I, J, K, L, M, N], ...}
 #
 #A = ID do Personagem
 #B = ID da SKILL.
 #C = Gasto de MP
 #D = Poder
 #E = Força F <--- ---> Correto: Ataque F
 #F = Fuga F     |-->No seu Database os nomes podem estar trocados.O sistema usa o padrão correto
 #G = Ataque F<--- ---> Correto: Força F
 #H = Defesa F---->Idem. Correto Destreza F
 #I = Agilidade F
 #J = Inteligência
 #K = % de Acerto
 #L = Defesa Fís.
 #M = Defesa Mag.
 #N = Grau de Dist.
 #
 #*É importante que coloque os valores na sequência descrita acima.
 #*OBS: Coloque 0(zero) se não quiser que o atributo aumente quando
 #o level da skill aumentar.
 #*OBS: Se quiser que o valor seja subtraido a cada level então
 #coloque um sinal de -(menos) antes. Ex: -45
 ATRIBUTE_SKILLS = []
 ATRIBUTE_SKILLS[1] = {
 2=>["-5%", "100%", "100%", 0, 0, 0, 0, "100%", 0, 0, "100%", 0],
 7=>[32, 22, 5, 2, 25, 3, 8, 29, 6, 5, 2, 1],
 9=>[40, 29, 15, 3, 15, 8, 7, 15, 3, 8, 3, 0],
 70=>[35, 28, 15, 0, 12, 8, 5, 36, 6, 8, 1, 0],
 72=>[30, 19, 20, 1, 11, 5, 7, 26, 3, 8, 3, -1]
 }
 ATRIBUTE_SKILLS[2] = {
 1=>[20, 23, 15, 3, 15, 8, 7, 15, 3, 8, 3, 0],
 8=>[35, 29, 15, 2, 12, 8, 7, 36, 6, 8, 3, 0],
 13=>[30, 19, 20, 1, 11, 5, 7, 26, 3, 8, 3, -1],
 63=>[35, 29, 15, 2, 12, 8, 7, 36, 6, 8, 3, 0],
 64=>[35, 28, 15, 0, 12, 8, 5, 36, 6, 8, 1, 0]
 }
 ATRIBUTE_SKILLS[3] = {
 9=>[10, 8, 15, 2, 18, 8, 7, 46, 6, 8, 3, 0],
 19=>[32, 22, 5, 2, 25, 3, 8, 29, 6, 5, 2, 1],
 21=>[30, 19, 20, 1, 11, 5, 7, 26, 3, 8, 3, -1],
 53=>[35, 29, 15, 2, 12, 8, 7, 36, 6, 8, 3, 0]
 }
 ATRIBUTE_SKILLS[4] = {
 22=>[-11, 29, 15, 2, 12, 8, 7, 36, 6, 8, 3, 0],
 25=>[30, 19, 20, 1, 11, 5, 7, 26, 3, 8, 3, -1],
 39=>[35, 29, 15, 2, 12, 8, 7, 36, 6, 8, 3, 0],
 60=>[35, 29, 15, 2, 12, 8, 7, 36, 6, 8, 3, 0],
 61=>[28, 29, 15, 2, 12, 8, 7, 36, 6, 8, 3, -2]
 }
 ATRIBUTE_SKILLS[5] = {
 24=>[35, 24, 15, 2, 12, 8, 7, 21, 6, 8, 3, 0],
 73=>[15, 9, 15, 2, 12, 8, 7, 36, 4, 8, 3, 0],
 74=>[50, 19, 15, 2, 12, 0, 7, 13, 6, 8, 3, 0],
 75=>[28, 22, 15, 0, 12, 8, 0, 26, 8, 8, 13, -2],
 76=>[30, 10, 15, 2, 12, 1, 7, 36, 6, 8, 3, 0]
 }
 #----------------------------------------------------------------------------------------

 #Definição do nome dos atributos para que apareceram na descrição
 #da habilidade.São 12 atributos portanto 12 palavras.
 #
 #-------------------
 #ATR_WORDS = {
 #"SP"=>A,
 #"PWR"=>B,
 #"ATK"=>C,
 #"EVA"=>D,
 #"STR"=>E,
 #"DEX"=>F,
 #"AGI"=>G,
 #"INT"=>H,
 #"HIT"=>I,
 #"PDEF"=>J,
 #"MDEF"=>K,
 #"VAR"=>L
 #}
 #--------------------
 #A = Gasto de MP
 #B = Poder
 #C = Força F <--- ---> Correto: Ataque F
 #D = Fuga F     |-->No seu Database os nomes podem estar trocados.O script usa o padrão correto
 #E = Ataque F<--- ---> Correto: Força F
 #F = Defesa F---->Idem. Correto Destreza F
 #G = Agilidade F
 #H = Inteligência
 #I = % de Acerto
 #J = Defesa Fís.
 #K = Defesa Mag.
 #L = Grau de Dist.
 #--------------------
 #
 #* A menos que saiba o que está fazendo não altere os valores que
 #estão antes do =>  EX: "SP"=>
 ATR_WORDS = {
 "SP"=>"MP",
 "PWR"=>"POD",
 "ATK"=>"ATQ",
 "EVA"=>"FUG",
 "STR"=>"FOR",
 "DEX"=>"DES",
 "AGI"=>"AGI",
 "INT"=>"INT",
 "HIT"=>"% Acerto",
 "MDEF"=>"DEF M",
 "PDEF"=>"DEF F",
 "VAR"=>"Grau de Dist."
 }
 #------------------------------------------------------------------                   
 
 #Condição para aprender a magia.Defina o level minimo que outras
 #magias devem estar para poder aprender uma determinada magia.
 #
 #CONDITION_SKILL[A] = {B=>{C=>D, C=>D, ...}, B=>{C=>D, C=>D, ...}}
 #
 #A = ID do personagem.
 #B = ID da SKILL.
 #C = ID da SKILL de condição para aprender a SKILL definida em B
 #D = Level minimo da SKILL da condição.
 #------------------------------------------------------------------
 #Ex: CONDITION_SKILL[1] = {
 #    2=>{1=>3, 4=>5}
 #    }
 #Isso significa que para o personagem de ID 1 precisa ter a skill
 #de ID 1 no level 3 e a skill de ID 4 no level 5 para poder
 #aprender a skill de ID 2.
 #
 #*Todas outras magias não definidas aqui não tem condições.
 CONDITION_SKILL = []
 CONDITION_SKILL[1] = {
 7=>{1=>2, 4=>2},
 9=>{1=>2, 4=>2},
 70=>{1=>2, 4=>2},
 72=>{1=>2, 4=>2}
 }
 CONDITION_SKILL[2] = {
 1=>{1=>2, 4=>2},
 8=>{1=>2, 4=>2},
 13=>{1=>2, 4=>2},
 63=>{1=>2, 4=>2},
 64=>{1=>2, 4=>2}
 }
 CONDITION_SKILL[3] = {
 9=>{1=>2, 4=>2},
 19=>{1=>2, 4=>2},
 21=>{1=>2, 4=>2},
 53=>{1=>2, 4=>2}
 }
 CONDITION_SKILL[4] = {
 22=>{1=>2, 4=>2},
 25=>{1=>2, 4=>2},
 39=>{1=>2, 4=>2},
 60=>{1=>2, 4=>2},
 61=>{1=>2, 4=>2}
 }
 CONDITION_SKILL[5] = {
 24=>{1=>2, 4=>2},
 73=>{1=>2, 4=>2},
 74=>{1=>2, 4=>2},
 75=>{1=>2, 4=>2},
 76=>{1=>2, 4=>2}
 }
 #----------------------------------------------------------------
 
 #Definição dos tipos das habilidades.
 #
 #TYPE_SKILL = {A=>B, A=>B, ...}
 #
 #A = ID da SKILL.
 #B = Tipo da SKILL.
 #
 #* Passivas: B = 0 ; Ofensivas: B = 1 ; c/ Armas: B = 2
 #*Todas magias não definidas aqui serão automaticamente consideradas
 #do tipo Ofensiva (B = 1).
 TYPE_SKILL = {
 1=>0,
 2=>0,
 7=>1,
 8=>1,
 9=>1,
 13=>1,
 19=>1,
 21=>1,
 22=>1,
 24=>1,
 25=>1,
 39=>1,
 53=>0,
 60=>2,
 61=>2,
 63=>2,
 64=>2,
 70=>2,
 72=>2,
 73=>2,
 74=>2,
 75=>2,
 76=>2
 }
 #-------------------------------------------------------
 
 #Defina o tipo da arma para ser usado como condição para magias
 #que foram definidas como habilidades c/ armas na configuração
 #acima.
 #
 #WEAPON_TYPE = {A=>B, A=>B, ...}
 #
 #A = ID da ARMA.
 #B = Tipo de Arma.
 #
 #* Para o valor de B use números e fique a vontade para criar
 #quantos tipos de armas desejar.Fique atento porque o valor de B
 # aqui adotado terá que ser adotado na próxima configuração.
 #Ex: Meu padrão será 0 = laminas, 1 = lanças, 2 = flechas.
 WEAPON_TYPE = {
 1=>0,
 5=>1,
 13=>0,
 17=>2
 }
 #---------------------------------------------------------------
 #WEAPON_SKILLTYPE = {A=>B, A=>B, ...}
 #
 #A = ID da SKILL.
 #B = Tipo de Arma.
 #
 #* Lembre-se o valor de B terá que ser o mesmo usado na
 #configuração anterior.
 #Ex:
 #WEAPON_TYPE = {
 #23=>1
 #12=>1
 #3=>4
 #}
 #WEAPON_SKILLTYPE = {
 #5=>1
 #}
 #-------------------------------------------------------------------
 #Ou seja, "Magia de ID número 5 só poderá ser usado se herói estiver
 #equipado com um equipamento do tipo 1, que em nosso caso existe
 #o equipamento de ID número 23 e ID número 12".
 #*Lembre-se de configurar TYPE_SKILL como "c/ Armas" para as
 #magias que forem configuradas aqui.
 WEAPON_SKILLTYPE = {
 60=>0,
 61=>0,
 63=>1,
 64=>1,
 70=>0,
 72=>0,
 73=>2,
 74=>2,
 75=>2,
 76=>2
 }           
 #--------------------------------------------------------------------
 
#================================================================
#                     Fim da Configuração
#          NÃO Altere nada apartir daqui se não souber
#================================================================
end

#==========================================================================
# Game_Actor(Modificação)
#----------------------------------------------------------------
# Modificações na classe Game_Actor para adicionar o Sistema de Skill Tree.
#==========================================================================

class Game_Actor < Game_Battler
 
  attr_reader     :ini_skillpoint
 
 #------------------------------------------------------
 #Acrescentando informações no metodo de setup da classe
 #------------------------------------------------------
 
 alias zc_skillpoints_setup setup
 def setup(actor_id)
  zc_skillpoints_setup(actor_id)
  @add_atributes = []
  @actor_id = actor_id
  @gain_skillpoint_levelup = ZC_SKP::SKP_EXP[actor_id]
  @ini_skillpoint = ZC_SKP::INI_SKP[actor_id]
  @max_skill_level = []
  @max_skill_level = ZC_SKP::MAX_SKILL_LV[actor_id].dup if ZC_SKP::MAX_SKILL_LV[actor_id] != nil
  @ini_skill_level = []
  @ini_skill_level = ZC_SKP::INI_SKILL_LV[actor_id].dup if ZC_SKP::INI_SKILL_LV[actor_id] != nil
  @skill_level = @ini_skill_level.dup if @skill_level == nil
  @verify_ini_skl_lv = @ini_skill_level.dup if @verify_ini_skl_lv == nil
  @atr_skl_levelup = {}
  @atr_skl_levelup = ZC_SKP::ATRIBUTE_SKILLS[actor_id].dup if ZC_SKP::ATRIBUTE_SKILLS[actor_id] != nil
  if @ini_skillpoint != nil
   @base_skp = @ini_skillpoint
  else
   @base_skp = 0
  end
  @skp = @base_skp
  if @gain_skillpoint_levelup != nil
   skpx = (@gain_skillpoint_levelup * @level) - @gain_skillpoint_levelup
  else
   @gain_skillpoint_levelup = 1
  end
  @skp = @base_skp
  for i in 1..$data_skills.size
   skill_atributes(i)
  end
 end

 #----------------------------------------------
 #Operadores de SKILL :Somar/Subtrair/Subtituir
 #----------------------------------------------
 #Para somar um level à skill apenas colque o
 #valor a ser somado no argumento value, para
 #subtrair coloque o valor negativo e para
 #redefinir coloque o novo valor em value e use
 #true no argumento substituir.
 
 def skill_operator(id_skill, value, substituir=false)
  if @skill_level[id_skill] == nil ; @skill_level[id_skill] = 0 end
  if substituir ; @skill_level[id_skill] = value else @skill_level[id_skill] += value end
  skill_atributes(id_skill)
 end
   
 #-----------------------------------------------------------
 #Retorna o level da habilidade
 #-----------------------------------------------------------
 
 def skill_level(id_skill)
   @skill_level = [] if @skill_level == nil
   if @skill_level[id_skill] != nil ; return @skill_level[id_skill] else @skill_level[id_skill] = 0 end
 end 

 #-----------------------------------------------------------
 #Retorna o level inicial da habilidade
 #-----------------------------------------------------------
 
 def ini_skill_level(id_skill)
   @ini_skill_level = [] if @ini_skill_level == nil
   if @ini_skill_level[id_skill] != nil ; return @ini_skill_level[id_skill] else @ini_skill_level[id_skill] = 0 end
 end
   
 #-----------------------------------------------------------
 #Retorna o level máximo da habilidade
 #-----------------------------------------------------------
 
 def max_skill_level(id_skill)
   @max_skill_level = [] if @max_skill_level == nil
   if @max_skill_level[id_skill] != nil ; return @max_skill_level[id_skill] else @max_skill_level[id_skill] = 0 end
 end
   
 #--------------------------------------------
 #Operadores de SKP :Somar/Subtrair/Subtituir
 #--------------------------------------------
 #Para somar um level à skill apenas colque o
 #valor a ser somado no argumento skp, para
 #subtrair coloque o valor negativo e para
 #redefinir coloque o novo valor em skp e use
 #true no argumento substituir.
 
 def skp_operator(skp, substituir=false)
   if substituir ; @skp = skp else @skp += skp end
 end
 
 #-----------------------------------------------------------
 #Calculo da SKP ganha por level(configure o total de pontos
 #por level nas configurações)
 #-----------------------------------------------------------

 def skp
  if @gain_skillpoint_levelup != nil and @level > 1 
   cal =  @gain_skillpoint_levelup * @level
   return @skp + cal - @gain_skillpoint_levelup
  else
   return @skp
  end
end

 #-----------------------------------------------------------
 #Calculo dos atributos acrescentados por level às skills
 #(configure o total de pontos por level nas configurações)
 #-----------------------------------------------------------
 
 def skill_atributes(id_skill)
  @atr_skl_levelup = {} if  @atr_skl_levelup == nil
  @atr_skl_levelup[id_skill] = [] if @atr_skl_levelup[id_skill] == nil
  for i in 0..11
    @add_atributes[i] = 0 if @add_atributes[i] == nil
    @atr_skl_levelup[id_skill][i] = 0 if @atr_skl_levelup[id_skill][i] == nil
  end 
  if @atr_skl_levelup != nil and skill_level(id_skill) > 1
    for i in 0..11
      atributes_calc(id_skill, i)
    end 
  end
 end
 
 #-----------------------------------------------------------
 #Operadores de Atributosdas Skills :Somar/Subtrair/Subtituir
 #-----------------------------------------------------------
 #id_skill = ID da Habilidade a ser operada
 #-----------------------------------------------------------
 #atr = Atributo a ser alterado, os atributos são:
 #0 = sp_cost = Custo de SP
 #1 = power = Poder
 #2 = atk_f = Força F
 #3 = eva_f = Fuga F
 #4 = str_f = Ataque F
 #5 = dex_f = Defesa F
 #6 = agi_f = Agilidade F
 #7 = int_f = Inteligência F
 #8 = hit = % de Acerto
 #9 = mdef_f = Defesa Mag.
 #10 = pdef_f = Defesa Fís.
 #11 = variance = Grau de Dist.
 #-----------------------------------------------------------
 #Para somar apenas colque o valor a ser somado no argumento
 #value, para subtrair coloque o valor negativo e para
 #redefinir coloque o novo valor em value e use true no
 #argumento substituir.
 
 def add_atr_skill(id_skill, atr, value, substituir=false)
  if substituir ; @add_atributes[atr] = value else @add_atributes[atr] += value end
  skill_atributes(id_skill)
 end

#-----------------------------------------------------------
 #Metodo de verificação e operação de porcentagem
 #-----------------------------------------------------------
 #Este metodo serve para verificar se o valor do atributo
 #definido em ATRIBUTE_SKILLS é um valor em porcentagem, que
 #na configuração deve ser definido como dado do tipo string,
 #portanto é necessário a verificação e em seguida o calculo
 #porcentagem.
 
 def atributes_calc(id_skill, atr)
   if @atr_skl_levelup[id_skill][atr] =~ "%"
     @atr_skl_levelup[id_skill][atr].gsub!(/%/i) {""}
     if skill_level(id_skill) == @verify_ini_skl_lv[id_skill]
       @ini_skill_level[id_skill].times do
       case atr
       when 0
       $game_skills_zc[@actor_id][id_skill].sp_cost += (($game_skills_zc[@actor_id][id_skill].sp_cost * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 1
       $game_skills_zc[@actor_id][id_skill].power += (($game_skills_zc[@actor_id][id_skill].power * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 2
       $game_skills_zc[@actor_id][id_skill].atk_f += (($game_skills_zc[@actor_id][id_skill].atk_f * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 3
       $game_skills_zc[@actor_id][id_skill].eva_f += (($game_skills_zc[@actor_id][id_skill].eva_f * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 4
       $game_skills_zc[@actor_id][id_skill].str_f += (($game_skills_zc[@actor_id][id_skill].str_f * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 5
       $game_skills_zc[@actor_id][id_skill].dex_f += (($game_skills_zc[@actor_id][id_skill].dex_f * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 6
       $game_skills_zc[@actor_id][id_skill].agi_f += (($game_skills_zc[@actor_id][id_skill].agi_f * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 7
       $game_skills_zc[@actor_id][id_skill].int_f += (($game_skills_zc[@actor_id][id_skill].int_f * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 8
       $game_skills_zc[@actor_id][id_skill].hit += (($game_skills_zc[@actor_id][id_skill].hit * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 9
       $game_skills_zc[@actor_id][id_skill].mdef_f += (($game_skills_zc[@actor_id][id_skill].mdef_f * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 10
       $game_skills_zc[@actor_id][id_skill].pdef_f += (($game_skills_zc[@actor_id][id_skill].pdef_f * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 11
       $game_skills_zc[@actor_id][id_skill].variance += (($game_skills_zc[@actor_id][id_skill].variance * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       end 
       end
       @verify_ini_skl_lv[id_skill] = 0
       @atr_skl_levelup[id_skill][atr] = $` + "%"
     else
       case atr
       when 0
       $game_skills_zc[@actor_id][id_skill].sp_cost += (($game_skills_zc[@actor_id][id_skill].sp_cost * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 1
       $game_skills_zc[@actor_id][id_skill].power += (($game_skills_zc[@actor_id][id_skill].power * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 2
       $game_skills_zc[@actor_id][id_skill].atk_f += (($game_skills_zc[@actor_id][id_skill].atk_f * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 3
       $game_skills_zc[@actor_id][id_skill].eva_f += (($game_skills_zc[@actor_id][id_skill].eva_f * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 4
       $game_skills_zc[@actor_id][id_skill].str_f += (($game_skills_zc[@actor_id][id_skill].str_f * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 5
       $game_skills_zc[@actor_id][id_skill].dex_f += (($game_skills_zc[@actor_id][id_skill].dex_f * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 6
       $game_skills_zc[@actor_id][id_skill].agi_f += (($game_skills_zc[@actor_id][id_skill].agi_f * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 7
       $game_skills_zc[@actor_id][id_skill].int_f += (($game_skills_zc[@actor_id][id_skill].int_f * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 8
       $game_skills_zc[@actor_id][id_skill].hit += (($game_skills_zc[@actor_id][id_skill].hit * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 9
       $game_skills_zc[@actor_id][id_skill].mdef_f += (($game_skills_zc[@actor_id][id_skill].mdef_f * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 10
       $game_skills_zc[@actor_id][id_skill].pdef_f += (($game_skills_zc[@actor_id][id_skill].pdef_f * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       when 11
       $game_skills_zc[@actor_id][id_skill].variance += (($game_skills_zc[@actor_id][id_skill].variance * @atr_skl_levelup[id_skill][atr].to_f) / 100).to_i + @add_atributes[atr]
       end
       @atr_skl_levelup[id_skill][atr] = $` + "%"
     end
   else
     case atr
       when 0
       $game_skills_zc[@actor_id][id_skill].sp_cost = $data_skills[id_skill].sp_cost + @atr_skl_levelup[id_skill][atr] * (skill_level(id_skill) - 1) + @add_atributes[atr]
       when 1
       $game_skills_zc[@actor_id][id_skill].power = $data_skills[id_skill].power + @atr_skl_levelup[id_skill][atr] * (skill_level(id_skill) - 1) + @add_atributes[atr]
       when 2
       $game_skills_zc[@actor_id][id_skill].atk_f = $data_skills[id_skill].atk_f + @atr_skl_levelup[id_skill][atr] * (skill_level(id_skill) - 1) + @add_atributes[atr]
       when 3
       $game_skills_zc[@actor_id][id_skill].eva_f = $data_skills[id_skill].eva_f + @atr_skl_levelup[id_skill][atr] * (skill_level(id_skill) - 1) + @add_atributes[atr]
       when 4
       $game_skills_zc[@actor_id][id_skill].str_f = $data_skills[id_skill].str_f + @atr_skl_levelup[id_skill][atr] * (skill_level(id_skill) - 1) + @add_atributes[atr]
       when 5
       $game_skills_zc[@actor_id][id_skill].dex_f = $data_skills[id_skill].dex_f + @atr_skl_levelup[id_skill][atr] * (skill_level(id_skill) - 1) + @add_atributes[atr]
       when 6
       $game_skills_zc[@actor_id][id_skill].agi_f = $data_skills[id_skill].agi_f + @atr_skl_levelup[id_skill][atr] * (skill_level(id_skill) - 1) + @add_atributes[atr]
       when 7
       $game_skills_zc[@actor_id][id_skill].int_f = $data_skills[id_skill].int_f + @atr_skl_levelup[id_skill][atr] * (skill_level(id_skill) - 1) + @add_atributes[atr]
       when 8
       $game_skills_zc[@actor_id][id_skill].hit = $data_skills[id_skill].hit + @atr_skl_levelup[id_skill][atr] * (skill_level(id_skill) - 1) + @add_atributes[atr]
       when 9
       $game_skills_zc[@actor_id][id_skill].mdef_f = $data_skills[id_skill].mdef_f + @atr_skl_levelup[id_skill][atr] * (skill_level(id_skill) - 1) + @add_atributes[atr]
       when 10
       $game_skills_zc[@actor_id][id_skill].pdef_f = $data_skills[id_skill].pdef_f + @atr_skl_levelup[id_skill][atr] * (skill_level(id_skill) - 1) + @add_atributes[atr]
       when 11
       $game_skills_zc[@actor_id][id_skill].variance = $data_skills[id_skill].variance + @atr_skl_levelup[id_skill][atr] * (skill_level(id_skill) - 1) + @add_atributes[atr]
       end
   end
 end 
 
end

#==============================================================================
# Game_Battler(Modificação)
#------------------------------------------------------------------------------
# Modificações na classe Game_Battler para adicionar o Sistema de Skill Tree.
#==============================================================================

class Game_Battler
 
 #-----------------------------------------------------------
 # Modificação em item_effect para adicionar efeito de itens
 # que dão SKP.
 #-----------------------------------------------------------
 
 alias zc_item_effect item_effect
 def item_effect(item)
  if $game_temp.in_battle == false 
   item_skp_increase = ZC_SKP::ITEM_SKP_INCREASE[item.id]
   if item_skp_increase != nil
    self.skp_operator(item_skp_increase)
    return true
   end
  end
  zc_item_effect(item)
 end

end

#==============================================================================
# Scene_SkillTree
#------------------------------------------------------------------------------
# Esta classe processa todo o menu de skilltree.
#==============================================================================

class Scene_SkillTree     
 
  #--------------------------------------------------------------------------
  # - Inicialização dos Objetos
  #
  #     actor_index : Índice de Heróis
  #--------------------------------------------------------------------------
 
  def initialize(actor_index = 0, equip_index = 0)
    if $game_party.actors.size >= actor_index
     @actor_index = actor_index
    else
     @actor_index = 0
    end
  end
 
  #--------------------------------------------------------------------------
  # - Processamento Principal
  #--------------------------------------------------------------------------
 
  def main
    s1 = ZC_SKP::NAME_SKILLTYPE[0]
    s2 = ZC_SKP::NAME_SKILLTYPE[1]
    s3 = ZC_SKP::NAME_SKILLTYPE[2]
    ss1 = "Adicionar"
    ss2 = "Cancelar"
    # Selecionar Herói
    @actor = $game_party.actors[@actor_index]
    # Criar janelas
    @skill_descripition = Window_SkillDescription.new()
    @skill_descripition.visible = false
    @skill_window = Window_Skilltree.new(@actor)
    @skill_window.active = false
    @command_window = Window_Command.new(160,[s1, s2, s3])
    @command_window.x = 480
    @command_window.y = 352
    @skillpoints_window = Window_SkillPoints.new(@actor_index)
    @skilltype_text = Window_Types.new
    @skillchar = Window_SkillOf.new(@actor_index, ZC_SKP::NAME_SKILLTREE)
    @skill_info = Window_SkillInfo.new(@actor)
    @skill_decision = Window_Command.new(160,[ss1, ss2])
    @skill_decision.active = false
    @skill_decision.x = 180
    @skill_decision.y = 240
    @skill_decision.index = -1
    @skill_decision.visible = false
    # Executar transição
    Graphics.transition
    # Loop Principal
    loop do
      # Atualizar tela de Jogo
      Graphics.update
      # Atualizar a entrada de informações
      Input.update
      # Atualizar frame
      update
      # Abortoar loop se a tela for alterada
      if $scene != self
        break
      end
    end
    # Preparar para transição
    Graphics.freeze
    # Exibição das janelas
    @skill_descripition.dispose
    @command_window.dispose
    @skill_window.dispose
    @skillpoints_window.dispose
    @skilltype_text.dispose
    @skillchar.dispose
    @skill_info.dispose
    @skill_decision.dispose
  end
 
  #--------------------------------------------------------------------------
  # - Atualização do Frame
  #--------------------------------------------------------------------------
 
  def update
    # Atualizar janelas
    @skillpoints_window.update
    @skillpoints_window.refresh
    @skill_decision.update
    @skill_descripition.update
    # Se pressionado trocar para Scene_Skill.
    if Input.trigger?(Input::A) and @command_window.active
      # Reproduzir SE de cancelamento
      $game_system.se_play($data_system.decision_se)
      # Alternar para a tela de Menu
      $scene = Scene_Skill.new(@actor_index)
      return
    end
    # Se o botão R for pressionado
    if Input.trigger?(Input::R) and @command_window.active
      # Reproduzir SE de cursor
      $game_system.se_play($data_system.cursor_se)
      # O comando leva ao próximo Herói
      @actor_index += 1
      @actor_index %= $game_party.actors.size
      # Alternar o personagem
      $scene = Scene_SkillTree.new(@actor_index)
      return
    end
    # Se o botão L for pressionado
    if Input.trigger?(Input::L) and @command_window.active
      # Reproduzir SE de cursor
      $game_system.se_play($data_system.cursor_se)
      # O comando leva ao Herói anterior
      @actor_index += $game_party.actors.size - 1
      @actor_index %= $game_party.actors.size
      # Alternar o personagem
      $scene = Scene_SkillTree.new(@actor_index)
      return
    end
    # Atualizar janelas
    @skill_window.update
    @command_window.update
    @skilltype_text.refresh(@command_window.index)
    @skill_window.refresh(@command_window.index)
    @skill_info.refresh(@skill_window.skill, true) if @skill_window.active
    @skill_info.refresh(0) unless @skill_window.active
    @skill_info.refresh(@skill_window.skill, true) if @skill_descripition.visible == true
    if @skill_descripition.visible
      if ZC_SKP::MORE_INFO_KEY != nil
        if Input.trigger?(ZC_SKP::MORE_INFO_KEY)
          @skill_descripition.visible = false
          @skill_window.active = true
          @skill_window.visible = true
          return
        end
      end 
      # Se pressionar sair da janela de descrição
      if Input.trigger?(Input::B)
       @skill_descripition.visible = false
       @skill_window.active = true
       @skill_window.visible = true
       return
      end
    elsif @skill_decision.active
      # Se pressionar sair da janela de decisão
      if Input.trigger?(Input::B)
       # Reproduzir SE de cancelamento
       $game_system.se_play($data_system.cancel_se)
       @skill_decision.active = false
       @skill_decision.visible = false
       @skill_window.active = true
       @skill_window.visible = true
       return
      end
      # Se pressionar verificar condições antes de evoluir o level da skill
      if Input.trigger?(Input::C)
        case @skill_decision.index
        when 0
        if $game_party.actors[@actor_index].skp > 0
         verify_skill_condition = 0
         condition = ZC_SKP::CONDITION_SKILL.dup
         condition[@actor.id] = {} if condition[@actor.id] == nil
         for i in 1..$game_skills_zc[@actor.id].size
           condition[@actor.id][@skill_window.skill.id] = {} if condition[@actor.id][@skill_window.skill.id] == nil
           condition[@actor.id][@skill_window.skill.id][i] = 0 if condition[@actor.id][@skill_window.skill.id][i] == nil
           if $game_party.actors[@actor_index].skill_level(i) >= condition[@actor.id][@skill_window.skill.id][i]
             verify_skill_condition += 1
           end
         end
         max_level = ZC_SKP::MAX_SKILL_LV.dup
         max_level[@actor.id] = {} if max_level[@actor.id] == nil
         max_level[@actor.id][@skill_window.skill.id] = 10 if max_level[@actor.id][@skill_window.skill.id] == nil
         if verify_skill_condition == $game_skills_zc[@actor.id].size and $game_party.actors[@actor_index].skill_level(@skill_window.skill.id) <  max_level[@actor.id][@skill_window.skill.id]
          # Reproduzir SE de confirmação
          $game_system.se_play($data_system.decision_se)
          #Retirar um ponto de SKP e adicionar o level à magia
          $game_party.actors[@actor_index].skill_operator(@skill_window.skill.id, 1)
          $game_party.actors[@actor_index].skp_operator(-1)
          @skill_decision.active = false
          @skill_decision.visible = false
          @skill_window.active = true
          @skill_window.visible = true
          return
         else
          #Se as condições não forem satisfeitas para a skill
          # Reproduzir SE de error
          $game_system.se_play($data_system.buzzer_se)
         end
        else
         # Reproduzir SE de error
         $game_system.se_play($data_system.buzzer_se)
        end
        when 1
        # Reproduzir SE de cancelamento
        $game_system.se_play($data_system.cancel_se)
        @skill_decision.active = false
        @skill_decision.visible = false
        @skill_window.active = true
        @skill_window.visible = true
        return 
        end
      end 
    elsif @skill_window.active
      if Input.trigger?(Input::B)
       # Reproduzir SE de cancelamento
       $game_system.se_play($data_system.cancel_se)
       @command_window.active = true
       @skill_window.active = false
       @command_window.index = @command_window.index
       return
      end
      if Input.trigger?(Input::C)
        # Reproduzir SE de confirmação
        $game_system.se_play($data_system.decision_se)
        @skill_decision.active = true
        @skill_decision.visible = true
        @skill_decision.index = 0
        @skill_window.active = false
        @skill_window.visible = false
        return
      end
      if ZC_SKP::MORE_INFO_KEY != nil
        if Input.trigger?(ZC_SKP::MORE_INFO_KEY)
          @skill_descripition.refresh(@skill_window.skill.id, @actor.id)       
          @skill_descripition.visible = true
          @skill_window.active = false
          @skill_window.visible = false
          return
        end
      end 
    elsif @command_window.active
      if Input.trigger?(Input::B)
       # Reproduzir SE de cancelamento
       $game_system.se_play($data_system.cancel_se)
       # Alternar para a tela do menu
       $scene = Scene_Menu.new(1)
       return
      end
      if Input.trigger?(Input::C)
       temp_index = @skill_window.index
       cont = 0
       for i in 0...@actor.skills.size
        if ZC_SKP::TYPE_SKILL[@actor.skills[i]] == @command_window.index
          cont += 1
        end
       end
       if cont == 0 or cont == nil
        # Reproduzir SE de erro
        $game_system.se_play($data_system.buzzer_se)
        return
       end
       # Reproduzir SE de confirmação
       $game_system.se_play($data_system.decision_se)
       cont -= 1
       @skill_window.index = 0
       if temp_index > cont
        @skill_window.index = cont       
       else
        @skill_window.index = temp_index
       end
       @command_window.active = false
       @skill_window.active = true
      end     
    end
  end
 
end

#==============================================================================
# Window_SkillPoints
#------------------------------------------------------------------------------
# Janela que mostra quantos skill points(skp) o personagem tem para distribuir.
#==============================================================================

class Window_SkillPoints < Window_Base
 
  #--------------------------------------------------------------------------
  # - Inicialização dos Objetos
  #--------------------------------------------------------------------------
 
  def initialize(actor_index)
    super(480, 0, 160, 136)
    @actor = $game_party.actors[actor_index]
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $fontface
    self.contents.font.size = 24
    refresh
  end
 
  #--------------------------------------------------------------------------
  # - Atualização
  #--------------------------------------------------------------------------
 
  def refresh
    self.contents.clear
    self.contents.font.color = normal_color
    self.contents.font.size = 24
    self.contents.draw_text(4, 14, 120, 32, ZC_SKP::SKP_NAME, 1)
    self.contents.font.color = system_color
    self.contents.font.size = 22
    self.contents.draw_text(4, 54, 120, 26, @actor.skp.to_s, 1)
  end
end

#==============================================================================
# Window_SkillDescription
#------------------------------------------------------------------------------
# Janela que mostra a descrição da skill.
#==============================================================================

class Window_SkillDescription < Window_Base
 
  #--------------------------------------------------------------------------
  # - Inicialização dos Objetos
  #--------------------------------------------------------------------------
 
  def initialize()
    super(0, 136, 480, 344)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $fontface
    self.contents.font.size = 20
  end
 
  #--------------------------------------------------------------------------
  # - Atualização
  #-------------------------------------------------------------------------- 
 
  def refresh(skill_id=1, actor_id=1)
    @i = []
    skls = $game_skills_zc[actor_id]
    actor = $game_actors[actor_id]
    if ZC_SKP::ATRIBUTE_SKILLS[actor_id][skill_id] != nil
      atr = ZC_SKP::ATRIBUTE_SKILLS[actor_id][skill_id].dup
    else
      atr = []
      for i in 0..11
        atr[i] = 0
      end
    end 
    aw = ZC_SKP::ATR_WORDS
    condt = ZC_SKP::CONDITION_SKILL
    condt[actor_id] = {} if condt[actor_id] == nil
    for i in 1..$game_skills_zc[@actor.id].size
      condt[actor_id][skill_id] = {} if condt[actor_id][skill_id] == nil
      condt[actor_id][skill_id][i] = 0 if condt[actor_id][skill_id][i] == nil
    end
    skill_desc1 = <<DESC
Atributos por Level
         
#{aw["SP"]} #{atr[0]}\n#{aw["PWR"]} #{atr[1]}\n#{aw["ATK"]} #{atr[2]}
#{aw["EVA"]} #{atr[3]}\n#{aw["STR"]} #{atr[4]}\n#{aw["DEX"]} #{atr[5]}
#{aw["AGI"]} #{atr[6]}\n#{aw["INT"]} #{atr[7]}\n#{aw["HIT"]} #{atr[8]}
#{aw["PDEF"]} #{atr[9]}\n#{aw["MDEF"]} #{atr[10]}\n#{aw["VAR"]} #{atr[11]}

Necessita

DESC
    skill_desc2 = []
    index = 0
    for i in 1...condt[actor_id][skill_id].size
      if i != nil and condt[actor_id][skill_id][i] != 0
        skill_desc2[index] = "#{skls[i].name} Lv#{condt[actor_id][skill_id][i]}"
        @i[index] = i
        index += 1
      end
    end
    string1 = skill_desc1.split("\n")
    string2 = skill_desc2
    self.contents.clear
    self.contents.font.color = normal_color
    for i in 0...string1.size
      if i == 0 or i == 15 ; align = 1 else align = 0 end
      if i == 0 or i == 1 
        self.contents.draw_text(4, (i * 20), 448, 20, string1[i], align)
      end
      if i >= 2 and i < 14
        x = 4 + ((i - 2) * 154) -  (((i - 2) / 3).to_i) * 462
        y = (2 + ((i - 2 )/ 3).to_i) * 20
        self.contents.draw_text(x, y, 150, 20, string1[i], align)
      end
      if i >= 14
        self.contents.draw_text(4, (i / 2) * 20, 448, 20, string1[i], align)
      end 
    end
    i = 9
    for j in 0...string2.size
      if actor.skill_level(@i[j]) >= condt[actor_id][skill_id][@i[j]]
        self.contents.font.color = normal_color
      else
        self.contents.font.color = disabled_color
      end
      self.contents.draw_text(4 + ((j / 6).to_i) * 154, (i - ((j / 6).to_i * 6)) * 20, 150, 20, string2[j])
      i += 1
    end
  end
 
end

#==============================================================================
# Window_Types
#------------------------------------------------------------------------------
# Descreve o tipo de magias que estão na opção onde o indice se encontra.
#==============================================================================

class Window_Types < Window_Base
 
  #--------------------------------------------------------------------------
  # - Inicialização dos Objetos
  #--------------------------------------------------------------------------
 
  def initialize
    super(480, 136, 160, 216)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $fontface
    self.contents.font.size = 22
    @text = []
    refresh
  end
 
  #--------------------------------------------------------------------------
  # - Atualização
  #--------------------------------------------------------------------------
 
  def refresh(index = 0)
    case index
    when 0
      @text[0] = ZC_SKP::NAME_SKILLTYPE[0]
      self.contents.font.size = 14
      @text[1] = "são magias"
      self.contents.font.size = 22
      @text[2] = "usadas para suporte"
    when 1
      @text[0] = ZC_SKP::NAME_SKILLTYPE[1]
      @text[1] = "são habilidades"
      @text[2] = "usadas para ataque"
    when 2
      @text[0] = ZC_SKP::NAME_SKILLTYPE[2]
      self.contents.font.size = 14
      @text[1] = "são técnicas"
      self.contents.font.size = 22
      @text[2] = "usadas com armas"
    end
    self.contents.clear
    self.contents.font.color = normal_color
    self.contents.draw_text(4, 18, 120, 32, @text[0], 1)
    self.contents.draw_text(4, 64, 120, 32, @text[1], 1)
    self.contents.draw_text(4, 106, 120, 32, @text[2], 1)
  end
 
end

#==============================================================================
# Window_Skilltree
#------------------------------------------------------------------------------
# Janela de escolha de habilidades
#==============================================================================

class Window_Skilltree < Window_Selectable
 
  #--------------------------------------------------------------------------
  # - Inicialização dos Objetos
  #--------------------------------------------------------------------------
 
  def initialize(actor)
    super(0, 136, 480, 344)
    @actor = actor
    @column_max = 4
    refresh(0)
    self.index = 0
    # Se for em batalha, mover a janela e colocá-la em translucidez
    if $game_temp.in_battle
      self.y = 64
      self.height = 256
      self.back_opacity = 160
    end
  end
 
  #--------------------------------------------------------------------------
  # - Uso de Habilidades
  #--------------------------------------------------------------------------
 
  def skill
    return @data[self.index]
  end
 
  #--------------------------------------------------------------------------
  # - Atualização
  #--------------------------------------------------------------------------
 
  def refresh(skill_type)
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    for i in 0...@actor.skills.size
      if ZC_SKP::TYPE_SKILL[@actor.skills[i]] == nil
        ZC_SKP::TYPE_SKILL[@actor.skills[i]] = 1
      end 
      skill = $game_skills_zc[@actor.id][@actor.skills[i]]
      if skill != nil
        @data.push(skill) if ZC_SKP::TYPE_SKILL[@actor.skills[i]] == skill_type
      end
    end
    # Número de Itens. Se não for 0 desenhá-los.
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 32)
          self.contents.font.name = $fontface
    self.contents.font.size = $fontsize
      for i in 0...@item_max
        draw_item(i)
      end
    end
  end
 
  #--------------------------------------------------------------------------
  # - Desenhando Itens
  #
  #     index : Número de Itens
  #--------------------------------------------------------------------------
 
  def draw_item(index)
    skill = @data[index]
    if $game_actors[@actor.id].skill_level(skill.id) > 0
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end
    x = 4 + index % 4 * 120
    y = index / 4 * 32
    rect = Rect.new(x, y, self.width / @column_max - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    bitmap = RPG::Cache.icon(skill.icon_name)
    opacity = self.contents.font.color == normal_color ? 255 : 128
    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    self.contents.draw_text(x + 36, y, 204, 32, "Lv" + $game_actors[@actor.id].skill_level(skill.id).to_s, 0)
  end
 
end

#==============================================================================
# Window_SkillInfo
#------------------------------------------------------------------------------
# Janela que contem algumas informações sobre a magia(skill).
#==============================================================================

class Window_SkillInfo < Window_Base
 
  #--------------------------------------------------------------------------
  # - Inicialização dos Objetos
  #--------------------------------------------------------------------------
 
  def initialize(actor)
    super(0, 56, 480, 80)
    key = ZC_SKP::MORE_INFO_KEY
    case key
    when Input::X
    @str_key = "X"
    when Input::A
    @str_key = "A"
    when Input::B
    @str_key = "B"
    when Input::C
    @str_key = "C"
    when Input::Y
    @str_key = "Y"
    when Input::Z
    @str_key = "Z"
    when Input::L
    @str_key = "L"
    when Input::R
    @str_key = "R"
    when nil
    @str_key = "" 
    end
    @actor = actor
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $fontface
    self.contents.font.size = 22
    refresh(0)
  end
 
  #--------------------------------------------------------------------------
  # - Atualização
  #--------------------------------------------------------------------------
 
  def refresh(magic, active=false)
    self.contents.clear
    if active == true
      self.contents.font.size = 14
      if @str_key != ""
        y = 0
        self.contents.draw_text(-8, 24, 480, 32, "pressione #{@str_key} para mais informações", 1)
      else
        y = 8
      end
      self.contents.font.size = 22
      self.contents.font.color = normal_color
      string_lv = " Lv"  + $game_actors[@actor.id].skill_level(magic.id).to_s
      self.contents.draw_text(4, y, 480, 32, magic.name.to_s + string_lv, 3)
    end 
  end
end

#==============================================================================
# Window_SkillOf
#------------------------------------------------------------------------------
# Janela com nome e boneco do personagem selecionado na skilltree.
#==============================================================================
 
class Window_SkillOf < Window_Base
 
  #--------------------------------------------------------------------------
  # - Inicialização dos Objetos
  #--------------------------------------------------------------------------
 
  def initialize(character, name_skill_tree)
    @name_skill_tree = name_skill_tree
    @character = character
    @character_name = $game_party.actors[@character].name
    super(0, 0, 480, 56)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $fontface
    self.contents.font.size = 22
    refresh
  end
 
  #--------------------------------------------------------------------------
  # - Atualização
  #--------------------------------------------------------------------------
 
  def refresh
    self.contents.clear
    self.contents.font.color = normal_color
    actor = $game_party.actors[@character]
    draw_actor_graphic(actor, 12, 48)
    self.contents.draw_text(26, 0, 480, 32, @character_name, 3)
    self.contents.draw_text(4, 0, 420, 32, @name_skill_tree, 2)
  end
end

#==============================================================================
# Window_Skill(Modificação)
#------------------------------------------------------------------------------
# Modificações na classe Window_Skill para adicionar o Sistema de Skill Tree.
#==============================================================================

class Window_Skill < Window_Selectable
 
  #--------------------------------------------------------------------------
  # - Atualização
  #--------------------------------------------------------------------------
 
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    for i in 0...@actor.skills.size
      skill = $game_skills_zc[@actor.id][@actor.skills[i]]
      if skill != nil
        @data.push(skill) if $game_actors[@actor.id].skill_level(skill.id) > 0
      end
    end
    # Número de Itens. Se não for 0 desenhá-los.
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 32)
          self.contents.font.name = $fontface
    self.contents.font.size = $fontsize
      for i in 0...@item_max
        draw_item(i)
      end
    end
  end
 
  #--------------------------------------------------------------------------
  # - Desenhando Itens
  #
  #     index : Número de Itens
  #--------------------------------------------------------------------------
 
  def draw_item(index)
     skill = @data[index]
    if @actor.skill_can_use?(skill.id)
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end
    if ZC_SKP::TYPE_SKILL[skill.id] == 2
      unless ZC_SKP::WEAPON_TYPE[@actor.weapon_id] == ZC_SKP::WEAPON_SKILLTYPE[skill.id]
        self.contents.font.color = disabled_color
      end 
    end
    x = 4 + index % 2 * (288 + 32)
    y = index / 2 * 32
    rect = Rect.new(x, y, self.width / @column_max - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    bitmap = RPG::Cache.icon(skill.icon_name)
    opacity = self.contents.font.color == normal_color ? 255 : 128
    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    self.contents.draw_text(x + 28, y, 204, 32, skill.name, 0)
    self.contents.draw_text(x + 232, y, 48, 32, skill.sp_cost.to_s, 2)
  end
 
end 

#==============================================================================
# Scene_Skill(Modificação)
#------------------------------------------------------------------------------
# Modificações na classe Scene_Skill para adicionar o Sistema de Skill Tree.
# *Possíveis erros de compatibilidades podem acontecer caso esteja usando outro
# script de menu que modifique a Scene_Skill padrão, porem nada dificil de editar.
#==============================================================================

class Scene_Skill
 
  #--------------------------------------------------------------------------
  # - Atualização do Frame (Qunado a janela de Habilidades estiver ativa)
  #--------------------------------------------------------------------------
 
  def update_skill
    if Input.trigger?(Input::A)
      # Reproduzir SE de confirmação
      $game_system.se_play($data_system.decision_se)
      # Alternar para a tela de SkillTree
      $scene = Scene_SkillTree.new(@actor_index)
      return
    end
    # Se o botão B for pressionado
    if Input.trigger?(Input::B)
      # Reproduzir SE de cancelamento
      $game_system.se_play($data_system.decision_se)
      # Alternar para a tela de Menu
      $scene = Scene_Menu.new(1)
      return
    end
    # Se o botão C for pressionado
    if Input.trigger?(Input::C)
      # Selecionar dados escolhidos na janela de Habilidades
      @skill = @skill_window.skill
      # Aqui é verificado se é possível utilizar a Habilidade
      if @skill == nil or not @actor.skill_can_use?(@skill.id)
        # Reproduzir SE de erro
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      unless $game_actors[@actor.id].skill_level(@skill.id) > 0
       # Reproduzir SE de erro
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Reproduzir SE de OK
      $game_system.se_play($data_system.decision_se)
      # Se o efeito da Habilidade for um aliado
      if @skill.scope >= 3
        # Ativar janela alvo
        @skill_window.active = false
        @target_window.x = (@skill_window.index + 1) % 2 * 304
        @target_window.visible = true
        @target_window.active = true
        # Definir se o alcance é um aliado ou todo o grupo
        if @skill.scope == 4 || @skill.scope == 6
          @target_window.index = -1
        elsif @skill.scope == 7
          @target_window.index = @actor_index - 10
        else
          @target_window.index = 0
        end
      # Se o efeito for outro senão para um aliado
      else
        # Se o ID do evento comum for válido
        if @skill.common_event_id > 0
          # Chamar evento comum da reserva
          $game_temp.common_event_id = @skill.common_event_id
          # Reproduzir SE da Habilidade
          $game_system.se_play(@skill.menu_se)
          # Descontar MP
          @actor.sp -= @skill.sp_cost
          # Recriar cada conteúdo das janelas
          @status_window.refresh
          @skill_window.refresh
          @target_window.refresh
          # Alternar para a tela do Mapa
          $scene = Scene_Map.new
          return
        end
      end
      return
    end
    # Se o botão R for pressionado
    if Input.trigger?(Input::R)
      # Reproduzir SE de cursor
      $game_system.se_play($data_system.cursor_se)
      # O comando leva ao próximo Herói
      @actor_index += 1
      @actor_index %= $game_party.actors.size
      # Alternar para uma tela de Habilidades diferente
      $scene = Scene_Skill.new(@actor_index)
      return
    end
    # Se o botão L for pressionado
    if Input.trigger?(Input::L)
      # Reproduzir SE de cursor
      $game_system.se_play($data_system.cursor_se)
      # O comando leva ao Herói anterior
      @actor_index += $game_party.actors.size - 1
      @actor_index %= $game_party.actors.size
      # Alternar para uma tela de Habilidades diferente
      $scene = Scene_Skill.new(@actor_index)
      return
    end
  end

end 

#==============================================================================
# Scene_Battle(Modificação)
#------------------------------------------------------------------------------
# Modificações na classe Scene_Battle para adicionar o Sistema de Skill Tree.
# *Possíveis erros de compatibilidades podem acontecer caso esteja usando outro
# script de batalha que não seja o padrão, porem nada dificil de editar.
#==============================================================================

class Scene_Battle
 
  #--------------------------------------------------------------------------
  # - Atualização do Frame (Fase de Comandos do Herói : Seleção da Habilidade)
  #--------------------------------------------------------------------------
 
  def update_phase3_skill_select
    # Tornar a janela de Habilidades visível
    @skill_window.visible = true
    # Atualizar janela de Habilidades
    @skill_window.update
    # Se o botão B for pressionado
    if Input.trigger?(Input::B)
      # Reproduzir SE de Cancelamento
      $game_system.se_play($data_system.cancel_se)
      # Finializar selação da Habilidade
      end_skill_select
      return
    end
    # Se o botão C for pressionado
    if Input.trigger?(Input::C)
      # Selecionar os dados escolhidos na janela de Habilidades
      @skill = @skill_window.skill
      # Se não puder ser utilizado
      if @skill == nil or not @active_battler.skill_can_use?(@skill.id)
        # Reproduzir SE de Erro
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      if ZC_SKP::TYPE_SKILL[@skill.id] == 2 #se a habiliade precisa de uma arma
        unless ZC_SKP::WEAPON_TYPE[@active_battler.weapon_id] == ZC_SKP::WEAPON_SKILLTYPE[@skill.id]
          # Reproduzir SE de Erro
          $game_system.se_play($data_system.buzzer_se)
          return
        end
      end 
      unless $game_actors[@active_battler.id].skill_level(@skill.id) > 0
       # Reproduzir SE de erro
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Reproduzir SE de OK
      $game_system.se_play($data_system.decision_se)
      # Definir ação
      @active_battler.current_action.skill_id = @skill.id
      # Tornar a janela de Habilidade inivisível
      @skill_window.visible = false
      # Se o alvo do efeito for apenas um Inimigo
      if @skill.scope == 1
        # Iniciar a seleção do Inimigo
        start_enemy_select
      # Se o alvo do efeito for apenas um aliado
      elsif @skill.scope == 3 or @skill.scope == 5
        # Iniciar a seleçao do Herói
        start_actor_select
      # Se o alvo do efeito não for simples
      else
        # Finalizar a seleção da Habilidade
        end_skill_select
        # Ir para a entrada de comandos do próximo Herói
        phase3_next_actor
      end
      return
    end
  end
 
  #--------------------------------------------------------------------------
  # - Criação o Resultado das Habilidade
  #--------------------------------------------------------------------------
 
  def make_skill_action_result
    # Selecionar Habilidade
    @skill = $game_skills_zc[@active_battler.id][@active_battler.current_action.skill_id]
    # Se não for uma ação pré-definida
    unless @active_battler.current_action.forcing
      # Se for impossível utilizar porque não há MP suficiente
      unless @active_battler.skill_can_use?(@skill.id)
        # Limpar o Battler que estiver em uma ação pré-definida
        $game_temp.forcing_battler = nil
        # Alternar para o passo 1
        @phase4_step = 1
        return
      end
    end
    # Utilizar MP
    @active_battler.sp -= @skill.sp_cost
    # Atualizar a janela de Status
    @status_window.refresh   
    # Exibir o nome da Habilidade na janela de Ajuda
    @help_window.set_text(@skill.name, 1)
    # Definir o ID da animação
    @animation1_id = @skill.animation1_id
    @animation2_id = @skill.animation2_id
    # Definir o ID do Evento Comum
    @common_event_id = @skill.common_event_id
    # Definir os Battlers alvo
    set_target_battlers(@skill.scope)   
    # Aplicar os efeitos da Habilidade
    for target in @target_battlers
      target.skill_effect(@active_battler, @skill)
    end
  end

end

#==============================================================================
# Scene_Title(Modificação)
#------------------------------------------------------------------------------
# Modificações na classe Scene_Title para adicionar o Sistema de Skill Tree.
# *Possíveis erros de compatibilidades podem acontecer caso esteja usando script
# de pular introdução caso após introdução não volte para Scene_Title.
#==============================================================================

class Scene_Title
   
  alias zc_main main
  def main
    $data_actors        = load_data("Data/Actors.rxdata")
        $game_skills_zc = []
    for i in 1...$data_actors.size
     $game_skills_zc[i]    = load_data("Data/Skills.rxdata")
    end
    zc_main
  end
 
end

#==============================================================================
# Scene_Save(Modificação)
#------------------------------------------------------------------------------
# Modificações na classe Scene_Save para adicionar o Sistema de Skill Tree.
#==============================================================================

class Scene_Save < Scene_File
 
  alias zc_write_save_data write_save_data
  def write_save_data(file)
    zc_write_save_data(file)
    Marshal.dump($game_skills_zc, file)
  end
 
end

#==============================================================================
# Scene_Load(Modificação)
#------------------------------------------------------------------------------
# Modificações na classe Scene_Load para adicionar o Sistema de Skill Tree.
#==============================================================================

class Scene_Load < Scene_File
 
  alias zc_read_save_data read_save_data
  def read_save_data(file)
    zc_read_save_data(file)
    $game_skills_zc     = Marshal.load(file)
  end
 
end

Créditos e Agradecimentos

• Feito por zecomeia
  
• Ajuda indireta de Atoa e Rune Angel