###################################
#
#                      ADD-ON GTBS
#            Competences evolutives
#
###################################
=begin                                                      MODE D'EMPLOI
A chaque utilisation d'une competence par un héros, celui-ci reçoit de l'experience.
A terme, cette experience fait augmenter le niveau de la competence.
Ce qui joue sur la portée, la zone d'effet, le cout MP ou le taux d'effet de la competence.
Pour distinguer une competence evolutive des autres, il suffit d'inscrire      EVOL        dans la note de la competence.
Plutôt que de definir individuellement l'evolution de chaque competence, on defini un type d'evolution.
Si rien n'est precisé, le type par defaut sera utilisé.
Il existe deux codes :
      TEX      => type d'experience ( la façon dont le niveau de la competence evoluera )
Pour le definir, inscriver    TEX=1  dans la note de la competence ( tout doit etre collé )
      EVT      => type d'evolution ( la façon dont les caracteristiques de la competence evolueront )
Pour le definir, inscriver    EVT=1  dans la note de la competence ( tout doit etre collé )
En combat tactique, lors de la selection des competences, les touches Q/W permettent de changer le niveau
de la competence pour pouvoir utiliser celui qui convient le mieux à la situation.
=end
module GTBS_HK_evoskill
# Indiquer le montant d'experience que l'on reçoit à chaque utilisation de la competence.
  Use_exp = 5
# Indiquer le TEX par defaut qui sera utilisé si rien n'est spécifié dans la base de donnée
# ( et que la competence est bien une competence evolutive )
  Defaut_TEX = 1
# Indiquer le EVT par defaut qui sera utilisé si rien n'est spécifié dans la base de donnée
# ( et que la competence est bien une competence evolutive )
  Defaut_EVT = 1
# Configurer la table d'experience qui determinera le changement de niveau de la competence.
# A chaque type ( le TEX de la base de donnée ) correspond une table d'experience spécifique.
# Le premier nombre de la liste est toujours un 0
# Attention, il s'agit de la quantité d'experience necessaire pour evoluer !!
# Donc, pour le type 1, passer au niveau 3 demande : 25 + 75 = 100
#                  TEX        Exp necessaire
  Tab_exp = { 1 => [0, 25, 75, 250, 500],
                        2 => [0, 25, 50, 75, 100, 125, 150, 175, 200],
                        3 => [0, 100, 200, 300, 400, 500] }
                       
# Configurer la table d'evolution :
# Le niveau 1 est defini normalement ( GTBS_Move/Weapon/Skill et base de donnée )
# Range fonctionne comme celui du GTBS qu'il remplacera
# MP+, c'est l'augmentation du cout MP pour ce niveau.
# De 2 MP niveau 1, on passera à 8 MP niveau 3 ( 2 + 2 + 4 )
# Base_damage+, c'est l'augmentation du taux d'effet pour ce niveau.
# De 1 au niveau 1, on passera à 11 au niveau 3 ( 1 + 5 + 5 )
  Tab_evol = {}
#              EVT    LV              Range        MP+/Base_damage+ 
  Tab_evol[1] = { 2 => [[2, 1, false, true], 2,              5],
                              3 => [[2, 2, false, true], 4,              5],
                              4 => [[3, 2, false, true], 2,              5],
                              5 => [[3, 3, false, true], 4,              5],
                              6 => [[4, 3, false, true], 2,              5],
                              7 => [[4, 4, false, true], 4,              5],
                              8 => [[5, 4, false, true], 2,              5],
                              }
end
###################################
module GTBS
  def self.test_evol(skill_id)
    if $scene.active_battler != nil
      if $scene.active_battler.is_a?(Game_Actor) and $data_skills[skill_id].evol?
        $game_temp.range = $scene.active_battler.check_new_range(skill_id)
      end
    end
  end
end
###################################
class String
  def decoupe
    bloc = []
    self.split(/[\r\n]+/).each { |line| bloc.push(line) }
    return bloc
  end
end
###################################
class Game_Battler
  alias hk_evoskill_make_dmg make_obj_damage_value
  def make_obj_damage_value(user, obj)
    hk_evoskill_make_dmg(user, obj)
    if user.is_a?(Game_Actor) and obj.is_a?(RPG::Skill) and obj.evol?
      user.exp_skill_up(obj.id)
    end
  end
end
###################################
class Scene_Battle_TBS < Scene_Base
  attr_reader :active_battler
  alias hk_evol_skill_phase1 tbs_phase_1
  def tbs_phase_1
    hk_evol_skill_phase1
    if Input.trigger?(Input::R) and @windows["skill"].active
      @spell = @windows["skill"].skill
      return unless @spell.evol?
      if @active_battler.lv_skill[@spell.id] < @active_battler.get_lv_skill(@spell.id)
        Sound.play_cursor
        @active_battler.lv_skill[@spell.id] += 1
        @windows["skill"].refresh(@active_battler)
      else
        Sound.play_buzzer
      end
    end
    if Input.trigger?(Input::L) and @windows["skill"].active
      @spell = @windows["skill"].skill
      return unless @spell.evol?
      if @active_battler.lv_skill[@spell.id] > 1
        Sound.play_cursor
        @active_battler.lv_skill[@spell.id] -= 1
        @windows["skill"].refresh(@active_battler)
      else
        Sound.play_buzzer
      end
    end
  end
end
###################################
class Scene_Skill < Scene_Base
  def active_battler
    return @actor
  end
end
###################################
class Game_Temp
  attr_accessor :range
  alias hk_evoskill_init initialize
  def initialize
    hk_evoskill_init
    @range = nil
  end
end
###################################
module RPG
  class Skill < UsableItem
    def name
      if $scene.is_a?(Scene_Battle_TBS) or $scene.is_a?(Scene_Skill)
        actor = $scene.active_battler
        if actor.is_a?(Game_Actor) and evol?
          return @name + actor.check_new_name(@id)
        end
      end
      return @name
    end
    def mp_cost
      if $scene.is_a?(Scene_Battle_TBS) or $scene.is_a?(Scene_Skill)
        actor = $scene.active_battler
        if actor.is_a?(Game_Actor) and evol?
          return @mp_cost + actor.check_new_mp_cost(@id)
        end
      end
      return @mp_cost
    end
    def base_damage
      if $scene.is_a?(Scene_Battle_TBS) or $scene.is_a?(Scene_Skill)
        actor = $scene.active_battler
        if actor.is_a?(Game_Actor) and evol?
          return @base_damage + actor.check_new_base_damage(@id)
        end
      end
      return @base_damage
    end
    def evol?
      tab = @note.decoupe
      for line in tab
        if line.include?("EVOL")
          return true
        end
      end
      return false
    end
    def type_exp
      tab = @note.decoupe
      for line in tab
        if line.include?("TEX=")
          num = line.delete("TEX=")
          return num.to_i
        end
      end
      if evol?
        return GTBS_HK_evoskill::Defaut_TEX
      else
        return 0
      end
    end
    def evo_type
      tab = @note.decoupe
      for line in tab
        if line.include?("EVT=")
          num = line.delete("EVT=")
          return num.to_i
        end
      end
      if evol?
        return GTBS_HK_evoskill::Defaut_EVT
      else
        return 0
      end
    end
  end
end
###################################
class Game_Actor < Game_Battler
  attr_accessor :lv_skill
  alias hk_evoskill_setup setup
  def setup(actor_id)
    hk_evoskill_setup(actor_id)
    @exp_skill = Hash.new(0)
    @lv_skill = Hash.new(1)
  end
  def exp_skill_up(skill_id)
    @exp_skill[skill_id] += GTBS_HK_evoskill::Use_exp
  end
  def get_exp_skill(skill_id)
    return @exp_skill[skill_id]
  end
  def get_lv_skill(skill_id)
    return get_number(skill_id, "lv")
  end
  def get_next_lv_skill(skill_id)
    return get_number(skill_id, "next_lv")
  end
  def get_til_next_lv_skill(skill_id)
    return get_number(skill_id, "til_next_lv")
  end
  def get_number(skill_id, type)
    exp = @exp_skill[skill_id]
    ref = GTBS_HK_evoskill::Tab_exp[$data_skills[skill_id].type_exp]
    lv = 1
    num = ref[lv]
    while exp >= num
      exp -= num
      break if lv == ref.size
      lv += 1
      num = ref[lv]
    end   
    case type
    when "lv"
      return lv
    when "next_lv"
      return num
    when "til_next_lv"
      return num - exp
    end
  end
  def check_new_name(skill_id)
    return " Lv #{@lv_skill[skill_id]} / #{get_lv_skill(skill_id)}"
  end
  def check_new_base_damage(skill_id)
    num = 0
    for x in 1..@lv_skill[skill_id]
      num += check_evol(skill_id, "dmg", x)
    end
    return num
  end
  def check_new_mp_cost(skill_id)
    num = 0
    for x in 1..@lv_skill[skill_id]
      num += check_evol(skill_id, "mp", x)
    end
    return num
  end
  def check_new_range(skill_id)
    return check_evol(skill_id, "range")
  end
  def check_evol(skill_id, type, lv = 0)
    lv = @lv_skill[skill_id] if lv == 0
    skill = $data_skills[skill_id]
    ref = GTBS_HK_evoskill::Tab_evol[skill.evo_type]
    tab = ref[lv]
    case type
    when "range"
      if lv == 1
        return nil
      else
        return tab[0]
      end
    when "mp"
      if lv == 1
        return 0
      else
        return tab[1]
      end
    when "dmg"
      if lv == 1
        return 0
      else
        return tab[2]
      end
    end
  end
end
###################################

    $game_temp.range = nil
    test_evol(skill_id)
    return $game_temp.range if $game_temp.range != nil