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