#==============================================================================
# ** Rebirth System -- Par Ojiro v1.0
#------------------------------------------------------------------------------
# Système de Réincarnation
# Permet à un personnage de revenir au nv1 mais avec plus de capacités ou caractéristiques
# améliorées
#==============================================================================

#==============================================================================
# Apprendre de nouvelles discipline à vos personnages :
#==============================================================================
# Les personnages peuvent se réincarner simplement ou changer de discipline (Classe)
# Pour apprendre une nouvelle discipline à un de vos personnages utilisez la commande
# "Appellez script" dans un évènement et utilisez la ligne de code suivante :
#   $game_party.members[ID_HERO].learn_way(ID_CLASSE)#
# La discipline sera ensuite proposée dans la fênetre de Réincarnation
#==============================================================================

#==============================================================================
# Héritage :
#==============================================================================
# Lorsqu'un personnage se réincarne et qu'il souhaite changer de spécialisation.
# Il a la possibilité de conserver certaines compétences issues de sa spécialisation précédente.
# Ce taux de conservation sera indiqué, plus le niveau du personnage est haut au moment de réincarner
# plus ce taux est elevé.
#==============================================================================

module AOL_Rebirth
   
  Actors_Inc = Array.new()
  
  # Indiquez ici les pourcentages de bonus de chaque caractéristique obtenus a chaque réincarnation
  # Ci-dessous les valeurs par défaut pour chaque héros
  # Actors_Inc_Default = [MAXHP, MAXMP, ATK, DEF, SPI, AGI]
  # Les valeurs doivent être entrées en décimales : 0.1 pour 10%
  Actors_Inc_Default = [0.3,0.2,0.3,0.3,0.3,0.3]
  
  # Ci-dessous les héros qui bénéficieront de valeurs de bonus différents - Optionnel !
  # Actors_Inc[ID_HERO]
  Actors_Inc[0] = [0.3,0.2,0.3,0.3,0.3,0.3]
  
  # Afficher un message lorsqu'un personnage apprend une nouvelle discipline
  # Et lorsqu'il conserve ou oublie ses compétences précédentes
  Messages = true

end

class Game_Actor < Game_Battler
  attr_accessor   :rebirth_count          # Compteur de réincarnation
  attr_accessor   :ways_learnt          # Voies apprises
  
  #--------------------------------------------------------------------------
  # * Setup
  #     actor_id : actor ID
  #--------------------------------------------------------------------------  
  alias setup_AOL_Rebirth setup
  def setup(actor_id)
    @rebirth_count = 0
    @ways_learnt = []
    setup_AOL_Rebirth(actor_id)
  end
 
  #--------------------------------------------------------------------------
  # * Apprendre une nouvelle voie
  #--------------------------------------------------------------------------    
  def learn_way(id)
    if (!way_learnt?($data_classes[id].name))    
      @ways_learnt.push($data_classes[id].name)
      if (AOL_Rebirth::Messages)
        text = sprintf("%s a appris la discipline %s !", @name, $data_classes[id].name)
        $game_message.texts.push(text)
      end
    end
  end
  
  def way_learnt?(name)
    for j in 0..@ways_learnt.size-1
      if (name == @ways_learnt[j])
        return true
      end
    end
    return false
  end
  
  #--------------------------------------------------------------------------
  # * Modify Rebirth Count
  #--------------------------------------------------------------------------    
  def rcount_set(value)
    @rebirth_count = value
  end
  
  #--------------------------------------------------------------------------
  # * Process to Rebirth
  #--------------------------------------------------------------------------      
  def rebirth
    rcount_set(@rebirth_count+1)
    change_exp(0,true)
  end
  
  #--------------------------------------------------------------------------
  # * Process to Skills Inherit
  #--------------------------------------------------------------------------       
  def inherit_process
    for i in self.skills
      if (rand(100) > @level)
        if (AOL_Rebirth::Messages)
          text = sprintf("%s a oublié la compétence %s !", @name, i.name)
          $game_message.texts.push(text)
        end
        forget_skill(i.id)
      else
        if (AOL_Rebirth::Messages)
          text = sprintf("%s a conservé la compétence %s !", @name, i.name)
          $game_message.texts.push(text)
        end
      end
    end
    for i in self.class.learnings
      learn_skill(i.skill_id) if i.level <= @level
    end    
  end
  
  #--------------------------------------------------------------------------
  # * Get Basic Maximum HP
  #--------------------------------------------------------------------------
  def base_maxhp
    if (AOL_Rebirth::Actors_Inc[self.id] != nil)
      return (actor.parameters[0, @level]*(1+@rebirth_count*AOL_Rebirth::Actors_Inc[self.id][0])).to_i
    else
      return (actor.parameters[0, @level]*(1+@rebirth_count*AOL_Rebirth::Actors_Inc_Default[0])).to_i
    end
  end
  #--------------------------------------------------------------------------
  # * Get basic Maximum MP
  #--------------------------------------------------------------------------
  def base_maxmp
    if (AOL_Rebirth::Actors_Inc[self.id] != nil)
      return (actor.parameters[1, @level]*(1+@rebirth_count*AOL_Rebirth::Actors_Inc[self.id][1])).to_i
    else
      return (actor.parameters[1, @level]*(1+@rebirth_count*AOL_Rebirth::Actors_Inc_Default[1])).to_i
    end
  end
  #--------------------------------------------------------------------------
  # * Get Basic Attack
  #--------------------------------------------------------------------------
  def base_atk
    if (AOL_Rebirth::Actors_Inc[self.id] != nil)    
      n = (actor.parameters[2, @level]*(1+@rebirth_count*AOL_Rebirth::Actors_Inc[self.id][2])).to_i
    else
      n = (actor.parameters[2, @level]*(1+@rebirth_count*AOL_Rebirth::Actors_Inc_Default[2])).to_i
    end
    for item in equips.compact do n += item.atk end
    return n
  end
  #--------------------------------------------------------------------------
  # * Get Basic Defense
  #--------------------------------------------------------------------------
  def base_def
    if (AOL_Rebirth::Actors_Inc[self.id] != nil)    
      n = (actor.parameters[3, @level]*(1+@rebirth_count*AOL_Rebirth::Actors_Inc[self.id][3])).to_i
    else
      n = (actor.parameters[3, @level]*(1+@rebirth_count*AOL_Rebirth::Actors_Inc_Default[3])).to_i
    end
    for item in equips.compact do n += item.def end
    return n
  end
  #--------------------------------------------------------------------------
  # * Get Basic Spirit
  #--------------------------------------------------------------------------
  def base_spi 
    if (AOL_Rebirth::Actors_Inc[self.id] != nil)    
      n = (actor.parameters[4, @level]*(1+@rebirth_count*AOL_Rebirth::Actors_Inc[self.id][4])).to_i
    else
      n = (actor.parameters[4, @level]*(1+@rebirth_count*AOL_Rebirth::Actors_Inc_Default[4])).to_i
    end
    for item in equips.compact do n += item.spi end
    return n
  end
  #--------------------------------------------------------------------------
  # * Get Basic Agility
  #--------------------------------------------------------------------------
  def base_agi
    if (AOL_Rebirth::Actors_Inc[self.id] != nil)    
      n = (actor.parameters[5, @level]*(1+@rebirth_count*AOL_Rebirth::Actors_Inc[self.id][5])).to_i
    else
      n = (actor.parameters[5, @level]*(1+@rebirth_count*AOL_Rebirth::Actors_Inc_Default[5])).to_i
    end
    for item in equips.compact do n += item.agi end
    return n
  end
  
end

#==============================================================================
# ** Window_RebirthStatus
#------------------------------------------------------------------------------
#  This window displays actor parameter changes on the equipment screen, etc.
#==============================================================================

class Window_RebirthStatus < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     x     : window X coordinate
  #     y     : window Y corrdinate
  #     actor : actor
  #--------------------------------------------------------------------------
  def initialize(x, y, actor)
    super(x, y, 208, WLH * 9 + 32)
    @actor = actor
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    draw_actor_name(@actor, 4, 0)
    draw_actor_class(@actor, 4, WLH * 1)
    draw_actor_level(@actor, 4, WLH * 2)
    draw_parameter(0, WLH * 3, 0)
    draw_parameter(0, WLH * 4, 1)
    draw_parameter(0, WLH * 5, 2)
    draw_parameter(0, WLH * 6, 3)
    draw_parameter(0, WLH * 7, 4)
    draw_parameter(0, WLH * 8, 5)   
  end
  
  def set_actor(actor)
    @actor = actor
  end
  
  def set_parameter(type,value)
    case type
    when 0
      @new_hp = value
    when 1
      @new_sp = value
    when 2
      @new_atk = value
    when 3
      @new_def = value
    when 4
      @new_spi = value
    when 5
      @new_agi = value
    end    
  end
  #--------------------------------------------------------------------------
  # * Set Parameters After Equipping
  #     new_atk : attack after equipping
  #     new_def : defense after equipping
  #     new_spi : spirit after equipping
  #     new_agi : agility after equipping
  #--------------------------------------------------------------------------
  def set_new_parameters(new_hp, new_sp, new_atk, new_def, new_spi, new_agi)
    if @new_hp != new_hp or @new_sp != new_sp or @new_atk != new_atk or @new_def != new_def or
       @new_spi != new_spi or @new_agi != new_agi
      @new_hp = new_hp
      @new_sp = new_sp
      @new_atk = new_atk
      @new_def = new_def
      @new_spi = new_spi
      @new_agi = new_agi
      refresh
    end
  end
  #--------------------------------------------------------------------------
  # * Get Post Equip Parameter Drawing Color
  #     old_value : parameter before equipment change
  #     new_value : parameter after equipment change
  #--------------------------------------------------------------------------
  def new_parameter_color(old_value, new_value)
    if new_value > old_value      # Get stronger
      return power_up_color
    elsif new_value == old_value  # No change
      return normal_color
    else                          # Get weaker
      return power_down_color
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Parameters
  #     x    : draw spot x-coordinate
  #     y    : draw spot y-coordinate
  #     type : type of parameter (0 - 3)
  #--------------------------------------------------------------------------
  def draw_parameter(x, y, type)
    case type
    when 0
      name = Vocab::hp_a
      value = @actor.maxhp
      new_value = @new_hp
    when 1
      name = Vocab::mp_a
      value = @actor.maxmp
      new_value = @new_sp
    when 2
      name = Vocab::atk
      value = @actor.atk
      new_value = @new_atk
    when 3
      name = Vocab::def
      value = @actor.def
      new_value = @new_def
    when 4
      name = Vocab::spi
      value = @actor.spi
      new_value = @new_spi
    when 5
      name = Vocab::agi
      value = @actor.agi
      new_value = @new_agi
    end
    self.contents.font.color = system_color
    self.contents.draw_text(x + 4, y, 80, WLH, name)
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 90, y, 30, WLH, value, 2)
    self.contents.font.color = system_color
    self.contents.draw_text(x + 122, y, 20, WLH, ">", 1)
    if new_value != nil
      self.contents.font.color = new_parameter_color(value, new_value)
      self.contents.draw_text(x + 142, y, 30, WLH, new_value, 2)
    end
  end
end

#==============================================================================
# ** Scene_Rebirth by Ojiro
#------------------------------------------------------------------------------
#  This class performs the rebirth screen processing.
#==============================================================================

class Scene_Rebirth < Scene_Base
  #--------------------------------------------------------------------------
  # * Start processing
  #--------------------------------------------------------------------------
  def start
    super
    create_menu_background
    create_command_window
    @viewport = Viewport.new(0, 0, 544, 416)
    @help_window = Window_Help.new
    @help_window.openness = 0
    @help_window.open
    @help_window.viewport = @viewport
  end
  #--------------------------------------------------------------------------
  # * Create Command Window
  #--------------------------------------------------------------------------
  def create_command_window
    @actors = []
    for i in 0..$game_party.members.size-1
        @actors.push($game_party.members[i].name)
    end    
    @actors_window = Window_Command.new(112, @actors)
    @actors_window.x = 0
    @actors_window.y = 56
    @actors_window.active = true
    @actors_window.openness = 0
    @actors_window.open
    @actor = $game_party.members[0]
    s1 = "Réincarner"
    s2 = "Changer de Discipline"
    s3 = "Annuler"
    @rebirth_window = Window_Command.new(200, [s1, s2, s3])
    @rebirth_window.x = @actors_window.x+@actors_window.width
    @rebirth_window.y = @actors_window.y
    @rebirth_window.help_window = @help_window
    @rebirth_window.active = false
    @rebirth_window.index = -1
    @rebirth_window.openness = 0
    @rebirth_window.open
    @status_window = Window_RebirthStatus.new(544-208,56,@actor)
    @status_window.visible = false
    load_ways_window
  end
  #--------------------------------------------------------------------------
  # * Termination Processing
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_menu_background
    @viewport.dispose
    @actors_window.dispose
    @help_window.dispose
    @rebirth_window.dispose
    if @classes_window != nil
      @classes_window.dispose
    end
    @status_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Return to Original Screen
  #--------------------------------------------------------------------------
  def return_scene
    $scene = Scene_Map.new
  end
  #--------------------------------------------------------------------------
  # * Update Frame
  #--------------------------------------------------------------------------
  def update
    super
    update_menu_background
    @help_window.update
    @actor = $game_party.members[@actors_window.index]
    if @rebirth_window.active
      update_rebirth_selection
    elsif @actors_window.active
      update_actor_selection
    elsif @classes_window.active
      update_class_selection          
    end    
    if @status_window.visible
      @status_window.set_actor(@actor)
      @status_window.refresh
    end    
  end
  
  def calc_new_values
        @actor.rcount_set(@actor.rebirth_count+1)
        newhp = @actor.base_maxhp
        newsp = @actor.base_maxmp
        newatk = @actor.base_atk
        newdef = @actor.base_def
        newspi = @actor.base_spi
        newagi = @actor.base_agi
        @actor.rcount_set(@actor.rebirth_count-1)
        @status_window.set_new_parameters(newhp,newsp,newatk,newdef,newspi,newagi)
  end
  #--------------------------------------------------------------------------
  # * Update Actor Selection
  #--------------------------------------------------------------------------
  def update_actor_selection
    if @actor.rebirth_count != 0
      @help_window.set_text(@actor.name+" s'est réincarné "+@actor.rebirth_count.to_s+" fois.")
    else
      @help_window.set_text(@actor.name+" ne s'est jamais réincarné.")
    end
    if Input.trigger?(Input::B)
      Sound.play_cancel
      return_scene
    elsif Input.trigger?(Input::C)
        Sound.play_decision
        @actors_window.active = false
        @rebirth_window.visible = true
        @rebirth_window.active = true
        @rebirth_window.index =0
        @status_window.visible = true    
      end
  @actors_window.update
  end  
  #--------------------------------------------------------------------------
  # * Close Rebirth Window
  #--------------------------------------------------------------------------
  def close_rebirth_window
    @rebirth_window.visible = false
    @rebirth_window.active = false
    @rebirth_window.index = -1
    @actors_window.active = true
    @status_window.visible = false
  end
  #--------------------------------------------------------------------------
  # * Close Classes Window
  #--------------------------------------------------------------------------
  def close_classes_window
    @classes_window.visible = false
    @classes_window.active = false
    @classes_window.index = -1
    @rebirth_window.active = true
  end
  
  def load_ways_window
    @classes = []
    for i in 1..$data_classes.size-1
      if @actor.way_learnt?($data_classes[i].name)
        @classes.push($data_classes[i].name)
      end
    end
    @classes.sort!
    @classes_window = Window_Command.new(240, @classes)
    @classes_window.x = @rebirth_window.x
    @classes_window.y = @rebirth_window.y+@rebirth_window.height
    @classes_window.active = false
    @classes_window.help_window = @help_window
    @classes_window.index = -1
    @classes_window.openness = 0
    @classes_window.open
  end
  #--------------------------------------------------------------------------
  # * Update Rebirth Selection
  #--------------------------------------------------------------------------
  def update_rebirth_selection
    if (@actor.ways_learnt == [])
      @rebirth_window.draw_item(1,false)
    else
      @rebirth_window.draw_item(1,true)
    end
    case @rebirth_window.index
    when 0
    @help_window.set_text("Réincarner le personnage.")
    calc_new_values
    when 1
    @help_window.set_text("Réincarnation et changement de spécialisation.")
    calc_new_values
    when 2
    @help_window.set_text("Annuler la réincarnation.")
    end
  
    if Input.trigger?(Input::B)
      Sound.play_cancel
      close_rebirth_window
    elsif Input.trigger?(Input::C)
      case @rebirth_window.index
      when 0
        Sound.play_decision
        @actor.rebirth
        close_rebirth_window
        return_scene
      when 1
        if @actor.ways_learnt == []
          Sound.play_cancel
          return
        end
        Sound.play_decision
        @rebirth_window.active = false
        load_ways_window
        @classes_window.visible = true
        @classes_window.active = true
        @classes_window.index = 0
      when 2
        Sound.play_cancel
        close_rebirth_window
      end
    end
  @rebirth_window.update
  end
  #--------------------------------------------------------------------------
  # * Update Class Selection
  #--------------------------------------------------------------------------
  def update_class_selection
    @help_window.set_text("Vous avez "+@actor.level.to_s+"% de chance d'héritage.")
    if Input.trigger?(Input::B)
      Sound.play_cancel
      close_classes_window
    elsif Input.trigger?(Input::C)
      Sound.play_decision      
      for i in 1..$data_classes.size-1
        if $data_classes[i].name == @classes_window.commands[@classes_window.index]
          $game_party.members[@actors_window.index].class_id = i
        end
      end
      @actor.inherit_process
      @actor.rebirth
      close_classes_window
      return_scene
    end
    @classes_window.update
  end
  
end