###################################
#
#  Systeme de magie à la Rudora no Hihou
#
###################################
=begin
Le jeu "Rudora no hihou" utilise un systeme de magie unique en son genre.
Le joueur crée lui même ses magies en assemblant des syllabes de maniere à créer une formule magique.
Ce script permet d'integrer un systeme semblable dans votre jeu.
Les competences classiques sont toujours active, vous pouvez donc avoir des competences normales plus des formules.
Il suffit de créer dans l'onglet "Competences" de la base donnée vos syllabes.
Durant le jeu, le joueur aura l'occassion d'assembler plusieurs syllabes pour créer une formule utilisable en combat.
La formule est comme une addition des differentes informations des syllabes.
Ainsi, la puissance de la formule est l'addition des puissances des syllabes.
Même chose pour le cout MP, la vitesse d'execution, ...
Gardez bien ceci en tête au moment de definir vos syllabes.
Vous trouverais ci-dessous differentes options de configurations.
=end
module Rudora
###################################
# Mettre cet interrupteur sur "true" si les competences-syllabes se suivent dans la base de donnée.
  Suite = true
# Indiquez ici l'ID de la premiere competence-syllabe
  Min = 84
# Indiquez ici l'ID de la derniere competence-syllabe
  Max = 140
# Si les competences-syllabes ne se suivent pas, indiquez ici l'ID de toutes les competences-syllabes
  Liste = []
###################################
# Si l'interrupteur suivant est sur "true", toutes les competences-syllabes sont accessibles des le depart.
  Total = true
# Sinon, indiquez ici les ID de celles qui sont accessibles des le debut.
  Acces = []
# Pour en rajouter d'autres en cours de jeu, utiliser en insertion de script la commande suivante :
#                      $game_party.syllabe |= [ID, ID, ID, ID]
# ou ID est l'ID des competences-syllabes nouvellement accessibles.
###################################
# Ici, vous pouvez configurer le nombre de competences qu'un héros peut créer des le debut du jeu
#              ID héros => Nbr de competences
  Max_skill = {1 => 4, 2 => 6, 3 => 1, 4 => 0}
# Vous pouvez augmenter ce nombre en cours de jeu grace à l'insertion de script :
#                $game_actors[ID_héros].max_skill += 2
# ID_héros designe l'ID du héros qui verra sa limite augmenter, 2 est le nombre de competences qu'il gagne.
# Vous pouvez indexer les nombres de competences créable sur le niveau du héros.
# Pour cela, mettre sur "true" l'interrupteur suivant et configurer la liste se trouvant dessous.
  Max_skill_evol = true
  Max_skill_evol_liste = Hash.new
#                    Id du héros = Niveau => Augmentation de la limite 
  Max_skill_evol_liste[1] = {5 => 2, 10 => 3, 15 => 5}
  Max_skill_evol_liste[2] = {5 => 1, 10 => 2, 15 => 3}
  Max_skill_evol_liste[3] = {5 => 4, 10 => 5, 15 => 6}
  Max_skill_evol_liste[4] = {5 => 5, 10 => 5, 15 => 5}
# Attention, il s'agit d'indiquer l'augmentation, pas le nombre de competence accessibles.
# Il est donc toujours possible d'ajouter ponctuellement d'autres competences grace à l'insertion sus-mentionné.
###################################
# Ici, vous pouvez configurer le nombre de syllabe qu'un héros peut utiliser pour créer une formule magique
#            ID du héros => nbr maxi de syllabe utilisable dans une formule
  Max_syllabe = {1 => 3, 2 => 4, 3 => 4, 4 => 3}
# Vous pouvez augmenter ce nombre en cours de jeu grace à l'insertion de script suivante :
#                  $game_actors[ID_héros].max_syllabe += 1
# Ou ID_héros est à remplacer par l'ID du héros qui verra sa limite augmenter et 1 est le gain de syllabe
# Il est également possible d'indexer cette evolution sur le niveau du héros.
# Cela fonctionne de la même maniere que pour la limite des competences à créer.
  Max_syllabe_evol = true
  Max_syllabe_evol_liste = Hash.new
#                        Id du héros = Niveau => Augmentation de la limite 
  Max_syllabe_evol_liste[1] = {5 => 1, 10 => 1, 15 => 1}
  Max_syllabe_evol_liste[2] = {20 => 2}
  Max_syllabe_evol_liste[3] = {10 => 1, 25 => 1}
  Max_syllabe_evol_liste[4] = {10 => 1, 15 => 1, 25 => 1}
# Attention, il s'agit d'indiquer l'augmentation, pas le nombre de syllabes accessibles.
# Il est donc toujours possible d'ajouter ponctuellement d'autres syllabes grace à l'insertion sus-mentionné.
###################################
# L'interrupteur ci-dessous sert à autoriser la repetition de syllabe dans une formule
  Repetition = true
###################################
#                Reglagles des syllabes
###################################
# Lorsque plusieurs données entre en conflit, la formule aura les données ayant la plus haute priorité.
# Pour donner une priorité à votre syllabe, il suffit d'ecrire dans la note :
#                P=5              ( Collé ainsi )
# Cela donnera une priorité de 5 à la syllabe, si rien n'est indiqué la priorité sera  de 0.

# La puissance d'attaque de la formule est une addition des puissances d'attaques des syllabes.
# Ainsi la syllabe 1 possede 100 en puissance et la syllabe 2 possede -150 en puissance.
# La formule unissant ces deux syllabes sera un sort de soin de puissance -50.
# Pour créer des formules d'attaques, vous pouvez créer des syllabes spéciales
#  ayant comme mots clé dans la note              ATK            ( en majuscules )
# Cela aura pour effet d'annuler les puissances négatives des autres syllabes.
# Dans l'exemple precedent, si la syllabe 1 a l'effet ATK, la formule aura donc 250 en puissance.
# Le mots clé            SOIN                a l'effet inverse de ATK.
#  C'est-à-dire il augmente l'efficacité des syllabes de guérison ( ici le resultat sera -250 ).

# Les elements de la formules sont basé sur ceux additionné des syllabes.
# Vous avez plusieurs choix de configuration ( valable pour toutes les formules )
#            "all"          => Tous les elements des syllabes se trouvent dans la formule
# Cela peut donner des formules ayant à la fois l'element "Feu" et l'element "Glace"
#            "max"      => L'element le plus present dans les syllabes choisit determinera l'element de la formule
# Si l'element Feu est present dans trois syllabes et qu'aucun autre element est present autant de fois
# la formule aura alors l'element Feu et seulement lui ( les autres sont "oubliés" )
#            "opp"      => Supprime les elements consideré comme opposé.
# Un element "Feu" et un element "Glace" s'annule, deux "Feu" et un "Glace" donneront un "Feu" ...
# Remplissez la table ci-dessous pour definir les oppositions
 Tri_element = "all" # choix entre "all" / "max" / "opp"
 # Les elements s'oppose deux à deux.
 #                  Feu/Glace        Feu/Eau    Eclair/Eau    Terre/Vent    Lumiere/Tenebre
 Table_opp = [[9, 10],            [9, 12],        [11, 12],        [13, 14],                [15, 16]]
# Si vous utilisez la configuration "max", il est possible d'utiliser un effet "Bonus".
# Pour cela, l'interrupteur ci-dessous doit etre sur "true".
 Bonus = true
# A chaque fois qu'un element est present plusieurs fois dans les syllabes, le taux de bonus augmente
# ce qui au final fait augmenter la puissance de la formule
# Dans une configuration "max" ou l'element "Feu" est present 3 fois, le bonus augmentera trois fois
# Effet normal + ( 3 * bonus à 0.5 ) => 1 + 1.5 => Puissance multiplié par 2.5 !!
 Taux_bonus = 0.5
 
# Les etats sont egalement additionnés d'apres la configuration des syllabes.
# Ce qui peut conduire à des choses du genre une formule qui guéri un allié et lui inflige "Poison" ...
# Pour eviter cela, incrivez        POS          dans la note de l'etat s'il a un effet positif ( augmentation de stats )
# Si rien n'est indiqué, l'etat est consideré comme négatif pour la cible.
# Par defaut, seul les effets positifs seront "lancés" sur un héros, les autres sont "oubliés".
# En mettant le mots clé          INV            dans la note de la syllabe, l'etat pourra etre inversé.
# Ainsi, dans l'exemple precedent avec la mot INV, la formule guéri et en prime soigne "Poison".
# Sans le mot INV, l'etat "Poison" etant négatif, l'effet sera "oublié".

# Les données numerique ( variance, influence atk / magie, vitesse, coût MP ) sont basé sur l'addition des valeurs.
# Les autres données ( portée, event commun, animation, ... ) sont basé sur la plus haute priorité.
###################################
end
###################################
class Game_Skill
  attr_reader :id
  attr_reader :icon_index
  attr_reader :description
  attr_reader :note
  def initialize(tab)
    @tab = tab
    @id = 0
    @icon_index = 155
    @description = "Formule magique mystique"
    @note = ""
  end
 
  def name
    text = ""
    for id in @tab
      text += $data_skills[id].name
    end
    return text.capitalize
  end
 
  def speed 
    result = 0
    for id in @tab
      result += $data_skills[id].speed
    end
    return result
  end
 
  def type?
    atk = 0
    soin = 0
    for id in @tab
      atk += 1 if $data_skills[id].attaque?
      soin += 1 if $data_skills[id].soin?
    end
    if atk > soin
      return "atk"
    elsif soin > atk
      return "soin"
    else
      return ""
    end
  end
   
  def base_damage
    result = 0
    for id in @tab
      if type? == "atk"
        result += $data_skills[id].base_damage.abs
      elsif type? == "soin"
        result += (0 - $data_skills[id].base_damage.abs)
      else
        result += $data_skills[id].base_damage
      end
    end
    result = (result * bonus).round
    return result
  end
 
  def variance
    result = 0
    for id in @tab
      result += $data_skills[id].variance
    end
    return result
  end
   
  def atk_f
    result = 0
    for id in @tab
      result += $data_skills[id].atk_f
    end
    return result
  end
   
  def spi_f
    result = 0
    for id in @tab
      result += $data_skills[id].spi_f
    end
    return result
  end
   
  def mp_cost
    result = 0
    for id in @tab
      result += $data_skills[id].mp_cost
    end
    return result
  end
   
  def hit
    test = @tab.sort {|a, b| $data_skills[a].prior <=> $data_skills[b].prior}
    id = test.last
    return $data_skills[id].hit
  end

  def get_number(id)
      return element_set_total.find_all {|elt| elt == id }.size
  end
 
  def get_max_number
    test = {}
    tab = []
    for id in 0...$data_system.elements.size
      test[id] = get_number(id)
      tab.push(id) if test[id] > 0
    end
    tab.sort! {|a, b| test[a] <=> test[b] }
    return tab.empty? ? [] : [tab.last]
  end
 
  def element_set_total
    result = []
    for id in @tab
      result += $data_skills[id].element_set
    end
    return result
  end

  def element_set_all
    result = []
    for id in @tab
      result |= $data_skills[id].element_set
    end
    return result.compact
  end
 
  def element_set
    case Rudora::Tri_element
    when "all"
      return element_set_all
    when "max"
      return get_max_number
    when "opp"
      result = element_set_all
      for bloc in Rudora::Table_opp
        un = get_number(bloc[0])
        deux = get_number(bloc[1])
        if un > deux
          result.delete(bloc[1])
        elsif deux > un
          result.delete(bloc[0])
        end
      end
      return result
    end
  end
 
  def bonus
    if Rudora::Bonus
      if Rudora::Tri_element == "max"
        return 1 + (get_number(element_set[0]) * Rudora::Taux_bonus)
      end
    end
    return 1
  end
 
  def inverse?
    for id in @tab
      return true if $data_skills[id].inverse?
    end
    return false
  end

  def plus_state_set
    result = []
    for id in @tab
      if for_friend?
        for etat in $data_skills[id].plus_state_set
          if $data_states[etat].positif?
            result.push(etat) unless result.include?(etat)
          end
        end
      else
        for etat in $data_skills[id].plus_state_set
          unless $data_states[etat].positif?
            result.push(etat) unless result.include?(etat)
          end
        end
        if inverse?
          for etat in $data_skills[id].minus_state_set
            unless $data_states[etat].positif?
              result.push(etat) unless result.include?(etat)
            end
          end
        end
      end
    end
    return result
  end

 

 def minus_state_set
    result = []
    for id in @tab
      if for_friend?
        for etat in $data_skills[id].minus_state_set
          unless $data_states[etat].positif?
            result.push(etat) unless result.include?(etat)
          end
        end
        if inverse?
          for etat in $data_skills[id].plus_state_set
            unless $data_states[etat].positif?
              result.push(etat) unless result.include?(etat)
            end
          end
        end
      else
        for etat in $data_skills[id].minus_state_set
          if $data_states[etat].positif?
            result.push(etat) unless result.include?(etat)
          end
        end
      end
    end
    return result
  end
 
  def scope
    test = @tab.sort {|a, b| $data_skills[a].prior <=> $data_skills[b].prior}
    id = test.last
    return $data_skills[id].scope
  end

  def animation_id
    test = @tab.sort {|a, b| $data_skills[a].prior <=> $data_skills[b].prior}
    id = test.last
    return $data_skills[id].animation_id
  end

  def common_event_id
    test = @tab.sort {|a, b| $data_skills[a].prior <=> $data_skills[b].prior}
    id = test.last
    return $data_skills[id].common_event_id
  end
 
  def message1
    return " lance #{name} !!"
  end
 
  def message2
    return ""
  end

  def physical_attack
    for id in @tab
      test = $data_skills[id].physical_attack
      return test if test == true
    end
    return false
  end
 
  def damage_to_mp
    for id in @tab
      test = $data_skills[id].damage_to_mp
      return test if test == true
    end
    return false
  end

  def absorb_damage
    for id in @tab
      test = $data_skills[id].absorb_damage
      return test if test == true
    end
    return false
  end

  def ignore_defense
    for id in @tab
      test = $data_skills[id].ignore_defense
      return test if test == true
    end
    return false
  end
 
  def occasion
    if base_damage > 0
      return 1
    else
      return 0
    end
  end
#####
    def for_opponent?
      return [1, 2, 3, 4, 5, 6].include?(scope)
    end
    def for_friend?
      return [7, 8, 9, 10, 11].include?(scope)
    end
    def for_dead_friend?
      return [9, 10].include?(scope)
    end
    def for_user?
      return [11].include?(scope)
    end
    def for_one?
      return [1, 3, 4, 7, 9, 11].include?(scope)
    end
    def for_two?
      return [5].include?(scope)
    end
    def for_three?
      return [6].include?(scope)
    end
    def for_random?
      return [4, 5, 6].include?(scope)
    end
    def for_all?
      return [2, 8, 10].include?(scope)
    end
    def dual?
      return [3].include?(scope)
    end
    def need_selection?
      return [1, 3, 7, 9].include?(scope)
    end
    def battle_ok?
      return [0, 1].include?(occasion)
    end
    def menu_ok?
      return [0, 2].include?(occasion)
    end
#####
end
###################################
class String
  def decoupe
    bloc = []
    self.split(/[\r\n]+/).each { |line| bloc.push(line) }
    return bloc
  end
end
###################################
module RPG
  class State
    def positif?
      text = @note.decoupe
      for line in text
        if line.include?("POS")
          return true
        end
      end
      return false
    end
  end
  class Skill < UsableItem
    def prior
      text = @note.decoupe
      num = 0
      for line in text
        if line.include?("P=")
          num = line.delete("P=")
        end
      end
      return num.to_i
    end
    def attaque?
      text = @note.decoupe
      for line in text
        if line.include?("ATK")
          return true
        end
      end
      return false
    end
    def soin?
      text = @note.decoupe
      for line in text
        if line.include?("SOIN")
          return true
        end
      end
      return false
    end
    def inverse?
      text = @note.decoupe
      for line in text
        if line.include?("INV")
          return true
        end
      end
      return false
    end
  end   
end
###################################
class Game_Party < Game_Unit
  attr_accessor :syllabe
  alias rudora_init initialize
  def initialize
    rudora_init
    @syllabe = []
    if Rudora::Total
      if Rudora::Suite
        for id in Rudora::Min..Rudora::Max
          @syllabe.push(id)
        end
      else
        @syllabe |= Rudora::Liste
      end
    else
      @syllabe |= Rudora::Acces
    end
  end
end
###################################
class Game_Actor < Game_Battler
  attr_accessor :max_skill
  attr_accessor :reste_skill
  attr_accessor :max_syllabe
  alias rudora_setup setup
  def setup(actor_id)
    @max_skill = 0
    @max_skill = Rudora::Max_skill[actor_id] if Rudora::Max_skill.key?(actor_id)
    @reste_skill = @max_skill
    @max_syllabe = 0
    @max_syllabe = Rudora::Max_syllabe[actor_id] if Rudora::Max_syllabe.key?(actor_id)
    rudora_setup(actor_id)
    @skills.clear
    for i in self.class.learnings
      learn_skill($data_skills[i.skill_id]) if i.level <= @level
    end
    clear_extra_values
    recover_all
  end
 
  def level_up
    @level += 1
    for learning in self.class.learnings
      learn_skill($data_skills[learning.skill_id]) if learning.level == @level
    end
    if Rudora::Max_skill_evol
      if Rudora::Max_skill_evol_liste.key?(@actor_id)
        liste = Rudora::Max_skill_evol_liste[@actor_id]
        if liste.key?(@level)
          @max_skill += liste[@level]
          @reste_skill += liste[@level]
        end
      end
    end
    if Rudora::Max_syllabe_evol
      if Rudora::Max_syllabe_evol_liste.key?(@actor_id)
        liste = Rudora::Max_syllabe_evol_liste[@actor_id]
        if liste.key?(@level)
          @max_syllabe += liste[@level]
        end
      end
    end
  end
 
  def skills
    return @skills
  end
 
  def learn_skill(skill)
    unless skill_learn?(skill)
      @skills.push(skill)
      @skills.sort! {|a,b| a.id <=> b.id}
    end
  end

  def forget_skill(skill)
    @skills.delete(skill)
  end

  def skill_learn?(skill)
    return skills.include?(skill)
  end

  def skill_can_use?(skill)
    return false unless skill_learn?(skill)
    return false unless skill.is_a?(RPG::Skill) or skill.is_a?(Game_Skill)
    return false unless movable?
    return false if silent? and skill.spi_f > 0
    return false if calc_mp_cost(skill) > mp
    if $game_temp.in_battle
      return skill.battle_ok?
    else
      return skill.menu_ok?
    end
  end
end
###################################
class Game_BattleAction
  def skill
    if @battler.is_a?(Game_Actor)
      return skill? ? @skill_id : nil
    else
      return skill? ? $data_skills[@skill_id] : nil
    end
  end
end
###################################
class Scene_Battle < Scene_Base
  def determine_skill
    @active_battler.action.set_skill(@skill)
    @skill_window.active = false
    if @skill.need_selection?
      if @skill.for_opponent?
        start_target_enemy_selection
      else
        start_target_actor_selection
      end
    else
      end_skill_selection
      next_actor
    end
  end
end
###################################
class Scene_Rudora < Scene_Base
  def initialize(rang = 0)
    @rang = rang
    @actor = $game_party.members[@rang]
  end
 
  def start
    create_menu_background
    @tab = []
    @face = Window_Faceset.new(@actor)
    @info = Window_Info.new(@actor, nil)
    s1 = "Créer une formule"
    s2 = "Effacer une formule"
    s3 = "Retour"
    larg = 250
    @choix = Window_Command.new(larg, [s1, s2, s3])
    @choix.x = (544 / 2) - (larg / 2)
    @choix.y = (416 / 2) - (((3 * 24) + 32) / 2)
    @choix.draw_item(0, false) if @actor.reste_skill == 0
    @choix.draw_item(1, false) if @actor.reste_skill == @actor.max_skill
    @crea = Window_Syllabe.new
    @crea.visible = false
    @crea.active = false
    @supp = Window_Formule.new(@actor)
    @supp.visible = false
    @supp.active = false
  end
 
  def terminate
    dispose_menu_background
    @face.dispose
    @info.dispose
    @choix.dispose
    @crea.dispose
    @supp.dispose
  end
 
  def update
    update_menu_background
    @face.update
    @info.update
    @choix.update
    @crea.update
    @supp.update
    if @crea.active
      update_creation
      return
    elsif @supp.active
      update_supprime
      return
    end
    if Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Menu.new
    elsif Input.trigger?(Input::C)
      case @choix.index
      when 0
        if @actor.reste_skill == 0
          Sound.play_buzzer
        else
          Sound.play_decision
          @choix.visible = false
          @choix.active = false
          @crea.visible = true
          @crea.active = true
        end
      when 1
        if @actor.reste_skill == @actor.max_skill
          Sound.play_buzzer
        else
          Sound.play_decision
          @choix.visible = false
          @choix.active = false
          @supp.visible = true
          @supp.active = true
        end
      when 2
        Sound.play_decision
        $scene = Scene_Menu.new
      end
    elsif Input.trigger?(Input::R)
      Sound.play_cursor
      @rang += 1
      @rang = 0 if @rang == $game_party.members.size
      $scene = Scene_Rudora.new(@rang)
    elsif Input.trigger?(Input::L)
      Sound.play_cursor
      @rang -= 1
      @rang = ($game_party.members.size - 1) if @rang < 0
      $scene = Scene_Rudora.new(@rang)
    end
  end # def update
 
  def update_creation
    if Input.trigger?(Input::B)
      Sound.play_cancel
      if @tab == []
        $scene = Scene_Rudora.new(@rang)
      else
        @tab.delete(@tab.last)
        @info.refresh(@tab)
      end
    elsif Input.trigger?(Input::C)
      if @crea.item.is_a?(Integer)
        if  @tab.size < @actor.max_syllabe
          if Rudora::Repetition
            Sound.play_decision
            @tab.push(@crea.item)
            @info.refresh(@tab)
          else
            if @tab.include?(@crea.item)
              Sound.play_buzzer
            else
              Sound.play_decision
              @tab.push(@crea.item)
              @info.refresh(@tab)
            end
          end
        else
          Sound.play_buzzer
        end
      else
        if @tab.size == 0
          Sound.play_buzzer
        else
          Sound.play_decision
          @actor.learn_skill(Game_Skill.new(@tab))
          @actor.reste_skill -= 1
          $scene = Scene_Rudora.new(@rang)
        end
      end
    end
  end
 
  def update_supprime
    if Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Rudora.new(@rang)
    elsif Input.trigger?(Input::C)
      if @supp.item != nil
        Sound.play_decision
        @actor.forget_skill(@supp.item)
        @actor.reste_skill += 1
        @info.refresh(nil)
        @supp.refresh
      else
        Sound.play_buzzer
      end
    end
  end
 
end # end class
###################################
class Window_Faceset < Window_Base
  def initialize(actor)
    super(0, 0, 102, 128)
    @actor = actor
    refresh
  end
  def refresh
    self.contents.clear
    if @actor != nil
      draw_character(@actor.character_name, @actor.character_index, 35, 48)
      self.contents.draw_text(0, 64, 70, 24, @actor.name.to_s, 1)
    end
  end
end
###################################
class Window_Info < Window_Base
  def initialize(actor, formule)
    super(102, 0, 544 - 102, 128)
    @actor = actor
    refresh(formule)
  end
  def refresh(formule)
    self.contents.clear
    text = "Q / W => Changer de héros"
    self.contents.draw_text(0, 0, 410, 24, text, 1)
    text = "Nombre de magie disponibles : " + @actor.reste_skill.to_s + " / " + @actor.max_skill.to_s
    self.contents.draw_text(0, 24, 410, 24, text, 1)
    text = "Nombre maximum de syllabe par formule : " + @actor.max_syllabe.to_s
    self.contents.draw_text(0, 48, 410, 24, text, 1)
    if formule != nil
      text = "Formule : "
      form = ""
      for id in formule
        form += $data_skills[id].name.to_s if id != nil
      end
      text += form.capitalize
      self.contents.draw_text(0, 72, 410, 24, text, 1)
    end
  end
end
###################################
class Window_Syllabe < Window_Selectable
  def initialize
    super(0, 128, 544, 416 - 128)
    @column_max = 5
    self.index = 0
    refresh
  end

  def item
    return @data[self.index]
  end

  def refresh
    @data = []
    for id in $game_party.syllabe
      @data.push(id)
    end
    @data.push("Valider")
    @item_max = @data.size
    create_contents
    for i in 0...@item_max
      draw_item(i)
    end
  end

  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    item = @data[index]
    if item != nil
      rect.width -= 4
      if item.is_a?(Integer)
        text = $data_skills[item].name.upcase.to_s
      else
        text = item
      end
      self.contents.draw_text(rect.x, rect.y, rect.width, 24, text, 1)
    end
  end
end
###################################
class Window_Formule < Window_Selectable
  def initialize(actor)
    super(0, 128, 544, 416 - 128)
    @actor = actor
    @column_max = 2
    self.index = 0
    refresh
  end

  def item
    return @data[self.index]
  end

  def refresh
    @data = []
    for item in @actor.skills
      @data.push(item) if item.is_a?(Game_Skill)
    end
    @item_max = @data.size
    create_contents
    for i in 0...@item_max
      draw_item(i)
    end
  end

  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    item = @data[index]
    if item != nil
      rect.width -= 4
      draw_icon(item.icon_index, rect.x, rect.y, true)
      self.contents.draw_text(rect.x + 24, rect.y, rect.width - 24, WLH, item.name)
    end
  end
end
###################################