Script de Réincarnation !

Système de Réincarnation

Auteur : Ojiro

Principe du script : Ce script est une interface de réincarnation
fortement inspirée du T-RPG Disgaea, elle vous permettra de faire en
sorte que vos personnages puissent retourner au nv1 mais avec des bonus à
ses caractéristiques ou encore de changer de classe tout en conservant
des compétences de la classe précédente.

Instructions : Il ne suffit pas de créer un appel au menu
pour pouvoir utiliser le système judicieusement le menu permet juste de
réincarner vos personnages et si vous autorisez un appel au menu de
réincarnation librement le joueur pourra se réincarner a l'infini et
booster ses capacités à l'infini c'est pourquoi il est fortement conseillé de tester la démo.

Screens :


Script :

Code:


#==============================================================================
# ** 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
 

Démo : Télécharger la démo !

Voila, voila ! =D

C'est un script qui vient d'un membre de l'autre communauté de RPG Maker VX ! =)

En fait, c'est un peu comme les évolutions de monstres de Tales of Symphonia 2... Tu reviens niveau 1 avec un pourcentage de caractéristiques conservés... C'est vachement intéressant et je pense pouvoir m'inspirer de ToS deuxième du nom pour l'insérer dans un jeu.

Merci du partage !
Et hop, on crédite Ojiro ! =D

Je trouve aussi que ce script est sympa.
Je me suis dis que certains membres de la commu' aurez bien aimés l'avoir alors je l'ai posté.
Voila, voila.