Consolidator VX Ace

Ce script est une amélioration du "groupeur" pour RPG Maker VX proposé par s4suk3.

Objectif
Il est courant d'avoir un système de chenille, c'est une succession de personnages qui reproduit les mouvements du héros pour le suivre et ça donne une chenille visuelle. Ce n'est pas très crédible (même si je suis d'accord pour vous accorder (uhuh) que la crédibilité et les RPG ça fait 2), l'idée de ce script est donc de permettre de déplacer les suiveurs sous forme de groupe et non plus de chenille.

Le personnage élégamment entouré est le héros. Notez que cette disposition est un peu aléatoire et qu'il serait possible d'en avoir d'autres.
Dans le cas des chemins un peu plus étroits, le groupe tâche de s'adapter.

Bref, il s'agit d'un petit ajout que je trouve assez amusant dans les jeux !
Comme pour l'ancien script, si un personnage suiveur bloque le héros, il est possible en appuyant deux fois sur la flêche directionnelle de changer de place avec lui.

Ce qu'il apporte de plus
La première différence avec son grand frère est qu'il ne permet pas de gérer qu'un seul groupe mais plusieurs groupes, qui sont représentés par un meneur et des menés. Donc il est possible de créer des groupes de PNJ's qui circulent ensemble.
Ensuite, pour ceux qui se rappellent des vidéos, lorsque des groupés étaient trop loin de leur meneur, une bulle de "rage" faisait son apparition.

Il est possible de définir un rayon autour du groupe et tout membres en dehors de ce rayon sera considéré comme "perdu" (et il faudra donc aller le rechercher ou utiliser les stratégies de regroupement). Lorsqu'un PNJ est perdu, il peut "s'énerver" (et on voit apparaître une bulle au dessus de sa tête, ces bulles sont paramétrables, voir la rubrique de manipulation des membres).



Enfin il possède aussi des solutions de regroupement assez bourrines, lorsque les groupés ne peuvent être perdus !

• Ghost : les groupés viennent en mode fantôme, faisant fi des décors
  
• Teleport: les groupés se téléportent derrière le meneur
  
• Jump : mon mode favori, les menés sautent jusqu'au meneur.

Installation
Copiez/collez le script de préférence dans un nouveau script créé au dessus de Main. Si des scripts sont mal foutus et n'utilisent pas les astuces de compatibilité, voyez les soucis avec ceux-là...
Idéalement, ajoutez le Buzzer d'évents (Disponible ici) parce que c'est plus amusant de voir les PNJ tressaillir lorsqu'ils sont perdus.
Cependant, si vous ne l'installez pas, le script fonctionnera toujours très bien !

Utilisation
L'objectif de ce script est avant tout d'offrir plus de possibilités que l'ancien, nous allons donc voir pas à pas comment créer/manipuler des groupes.

Créer un groupe
La création d'un groupe se fait au moyen d'un appel de script.

Code:


create_group(id, lost_zone, decal, type, leader, events_groupés)


• id : Comme il est possible de gérer nos groupes (multiples), l'id permettra d'accéder à un groupe rapidement (donc à numéroter de 0 à ce que vous voulez)
  
• lost_zone, correspond au nombre de cases du meneur (en tenant compte du nombre de groupés) qu'il faudra pour qu'un groupé soit perdu
  
• decal, correspond aux nombres de cases maximum ou le groupés se sentira près de son meneur, au dessus de 2 c'est généralement fort beaucoup, personnellement, j'alterne entre 1 et 2. decal doit être plus petit que lost_zone pour que les suiveurs ne se sentent pas continuellement perdus.
  
• type, correspond à la manière de se regrouper si des groupés sont perdus (les types sont expliqués plus haut), à choisir entre
  

  Code:

  :normal
:ghost
:teleport
:jump

  Rappellons que le type :normal est le seul qui ne regroupe pas les PNJ's
  
• leader, est l'id de l'evenement qui sera meneur d'un groupe (mettez 0 pour le héros).
  
• events, sera la liste des events du groupes (référencés par leur ID), vous pouvez mettre le héros leader dans son propre groupe de suiveurs mais c'est débile et ça ne sert à rien.
  

Voici donc un exemple type d'appel de script:

Code:


create_group(1,6, 2, :normal, 0, 1,2,3,4,5)


Qui créera le groupe 1, où les personnages seront "perdus" à 6 cases loin du groupe, sans aucun regroupement (typé normal donc), le leader sera le héros (0) et les membres groupés seront les évènement de 1 à 5.


Groupe simplifié

Code:

create_simple_group(id, leader, membres)

qui utilise les valeurs par défaut définies dans le module config au début


Modification d'un groupe
Une fois qu'un groupe est créé, il est possible de le modifier !
Pour appeler un groupe, il suffit de faire

Code:

group(ID du groupe)

L'ID étant celui défini dans create_group.

Récupérer un groupe ne sert pas à grand chose alors voici les fonctionnalités :

Modifier le type de regroupement:

Code:

group(ID).type = :type

Modifier le leader:

Code:

group(ID).leader = ID du leader

En modifiant le leader, le leader courant deviendra un membre du groupe et le nouveau leader sera celui référencé par l'id donné en paramètre.

Ajouter des membres

Code:

group(ID).add 1

Ajoutera l'event 1 au groupe.

Code:

group(ID).add 1,2,3,4,5

Ajoutera les events 1,2,3,4 et 5 au groupe.
Comme j'ai supposé que certains pouvaient être des trisomiques, si on ajoute un membre d'un groupe à un autre groupe, il sera retiré du premier groupe et ajouté au nouveau.

Retirer des membres

Code:

group(ID).remove 1

supprime l'event 1 du groupe.

Code:

group(ID).remove 1,2,3,4,5

Supprimera les events 1,2,3,4 et 5 du groupe.

Enlever tous les membres

Code:

group(ID).clear

Enlève tous les membres du groupe (les suiveurs, le leader reste)

Supprimer un groupe

Code:

group(ID).delete

Supprime le groupe (donc pour ajouter des membres, il faudra le recréer, je vous déconseille de l'utiliser.

Vérifie si un membre est dans le groupe

Code:

group(ID).member_exists? ID du membre

A utiliser dans une condition pour savoir si un membre (id event) est dans le groupe.

Modifier la distance de perdition

Code:

group(ID).lost_distance = X

Soit le nombre de case (+ le taille du groupe) avant qu'un PNJ soit perdu.
X étant un nombre (en général je met entre 5 et 7)

Modifier la proximité (decal)

Code:

group(ID).decal = X

Modifiera le décalage de proximité, (1, les PNJ seront le plus proche possible de leader, 2, ils s'arrêteront à proximité, X étant un nombre.
(au dessus de 2 ça fait beaucoup !)

Savoir combien de membres sont dans la lost zone

Code:

group(ID).miss_people

(Facilement mettable dans une variable avec la page 4, variable = script)

Savoir si le groupe est complet

Code:

group(ID).complete?

Permet de savoir si un groupe est complet, c'est à dire si tous les suiveurs sont dans leur zone de proximité autour du héros.
(facilement appelable dans une condition event avec Si script > group(9).complete?

A propos de la course
Dans un groupe où le héros est le meneur, si un groupé n'est pas "perdu", il court chaque fois que le héros court.
Il est possible de désactiver cette fonctionnalité en faisant:

Code:

group(ID).dash = false

De même que pour le réactiver:

Code:

group(ID).dash = true

A propos des membres
Il est aussi possible de manipuler les membres du groupe.

Savoir si un membre n'est pas perdu (c'est à dire est dans la lost_zone)

Code:

group(ID).missed? 10

Vérifiera si l'event 10 n'est pas perdu

Accéder à un membre facilement :

Code:

group(ID).member(ID de l'event)

Comme pour les groupes, accéder à ça permettra de le manipuler.

Changer la bulle :
Il est possible de définir une bulle en changeant "l'émotion" d'un membre. Les différents types de bulles sont :

Code:


:rage
:spite
:nervousness
:disturbed
:none


Ca n'affecte que leur bulle (sauf dans le cas de nervousness, mais nous y reviendrons plus tard), pour ne pas avoir de bulle, il suffit de mettre :none comme émotion.

Code pour changer la bulle :

Code:

group(ID).member(ID).emotion = :spite

Change l'émotion en :spite (dépit)

Savoir le nombre de fois qu'un event a été perdu :
(utile pour faire un mini jeu où il ne faut jamais perdre un event, ou pour altérer les dialogues en fonction des pertes)

Code:

group(ID).member(ID).frustration

C'est un nombre donc on peut facilement l'attribuer à une variable RM.


Astuces

• Il est possible de fusionner deux groupes, en mettant le leader d'un groupe comme membre dans un autre groupe.
  
• Il existe une syntaxe abrégée pour changer directement l'émotion:
  Au lieu d'utiliser un nombre pour ajouter un PNJ, utiliser event(ID, :emotion). Par exemple:
  

  Code:

  
create_group(1,6, 2, :normal, 0, event(1, :rage),2,3,4,5)


  L'event 1 aura directement :rage comme comportement.
  Cela fonctionne aussi avec la commande group(ID).add
  
• Avec le regroupement par saut, il serait envisageable de faire un mini jeu où des monstres sauteraient vers le héros.
  
• Le comportement :nervousness est un petit peu particulier, car en plus de changer la bulle, un PNJ nervousness fait abstraction du décalage pour tenter de toujours se rapprocher du meneur, et lorsqu'il est perdu, il fait plusieurs sauts d'exaspération sur place.
  

Le script

Code:

# Consolidator par S4suk3; Fabien; XHTMLBoy
# http://funkywork.blogspot.com

#==============================================================================
# ** Config_Consolidator
#------------------------------------------------------------------------------
#  Configuration du script
#==============================================================================

module Config_Consolidator

   #--------------------------------------------------------------------------
   # * Publication des méthodes
   #--------------------------------------------------------------------------
   extend self

   #--------------------------------------------------------------------------
   # * Rayon de non-perdition par défaut
   #--------------------------------------------------------------------------
   DEFAULT_LOST_ZONE = 6

   #--------------------------------------------------------------------------
   # * Décalage des menés par rapport au meneur par défaut
   #--------------------------------------------------------------------------
   DEFAULT_DECAL = 2


end


#==============================================================================
# ** Character_Utils
#------------------------------------------------------------------------------
#  Fonctions utiles
#==============================================================================

module Character_Utils

   #--------------------------------------------------------------------------
   # * Publication des méthodes
   #--------------------------------------------------------------------------
   extend self

   #--------------------------------------------------------------------------
   # * Retourne un caractère en fonction de son id
   #--------------------------------------------------------------------------
   def get(char)
      flag =  char.is_a?(Game_Character)
      char = (char == 0) ? $game_player : $game_map.events[char] unless flag
      char
   end

end

#==============================================================================
# ** Game_Character
#------------------------------------------------------------------------------
#  Ajoutes des outils de distances (et rend public certaines données)
#==============================================================================

class Game_Character

   #--------------------------------------------------------------------------
   # * Accesseurs / Mutateurs
   #--------------------------------------------------------------------------
   attr_accessor :through, :move_speed
   attr_reader :move_succeed

   #--------------------------------------------------------------------------
   # * Donne la distance entre deux caractères
   #--------------------------------------------------------------------------
   def distance_to(char)
      char = Character_Utils.get(char)
      coeff_x = @x - char.x
      coeff_y = @y - char.y
      Math.hypot(coeff_x, coeff_y)
   end

   #--------------------------------------------------------------------------
   # * Effectue une comparaison entre deux caractères par rapport a une cible
   #--------------------------------------------------------------------------
   def compare_distance(char, goal)
      char = Character_Utils.get(char)
      goal = Character_Utils.get(goal)
      distance_a = self.distance_to(goal)
      distance_b = char.distance_to(goal)
      result = -1
      result = 1 if distance_a > distance_b
      result = 0 if distance_b == distance_a
      result
   end

end

#==============================================================================
# ** Game_Event
#------------------------------------------------------------------------------
#  Ajoute la gestion des collisions
#==============================================================================

class Game_Event

   #--------------------------------------------------------------------------
   # * alias
   #--------------------------------------------------------------------------
   alias consolidator_update update

   #--------------------------------------------------------------------------
   # * Définis les collisions
   #--------------------------------------------------------------------------
   def collide
      temp_x = $game_player.x
      temp_y = $game_player.y
      if Input.trigger?(Input::DOWN) and @x==temp_x and @y-1==temp_y and $game_player.direction==2
         temp_through = @through
         @through=true
         $game_player.move_straight 2
         self.move_straight 8
         @through=temp_through
      end
      if Input.trigger?(Input::LEFT) and @x+1==temp_x and @y==temp_y and $game_player.direction==4
         temp_through = @through
         @through=true
         $game_player.move_straight 4
         self.move_straight 6
         @through=temp_through
      end
      if Input.trigger?(Input::RIGHT) and @x-1==temp_x and @y==temp_y and $game_player.direction==6
         temp_through = @through
         @through=true
         $game_player.move_straight 6
         self.move_straight 4
         @through=temp_through
      end
      if Input.trigger?(Input::UP) and @x==temp_x and @y+1==temp_y and $game_player.direction==8
         temp_through = @through
         @through=true
         $game_player.move_straight 8
         self.move_straight 2
         @through=temp_through
      end
   end

   #--------------------------------------------------------------------------
   # * Update
   #--------------------------------------------------------------------------
   def update
      flag = $game_map.groups.count{|group| group.member_exists?(@id) if group}
      collide if flag > 0
      consolidator_update
   end

   #--------------------------------------------------------------------------
   # * Vérifie si le caractère doit courrir
   #--------------------------------------------------------------------------
   def dash?
      flag = $game_map.groups.count do |group| 
         (group.member_exists?(@id) && group.leader.id == 0 && !group.missed?(@id) && group.dash?) if group
      end
      return $game_player.dash? && flag > 0
   end

end


#==============================================================================
# ** Pawn
#------------------------------------------------------------------------------
#  Déscription d'un membre du groupe
#==============================================================================

class Pawn

   #--------------------------------------------------------------------------
   # * Méthodes propre à la classe
   #--------------------------------------------------------------------------

   class << self

      #--------------------------------------------------------------------------
      # * Retourne un index en fonction d'un type
      #--------------------------------------------------------------------------
      def emoticone(type)
         case type
         when :rage
            return 7
         when :spite
            return 6
         when :nervousness
            return 5
         when :disturbed
            return 8
         else
            return 6
         end

      end
   end

   #--------------------------------------------------------------------------
   # * Accesseurs / Mutateurs
   #--------------------------------------------------------------------------
   attr_accessor :id, :emotion, :frustration

   #--------------------------------------------------------------------------
   # * Constructeur
   #--------------------------------------------------------------------------
   def initialize(id, emotion = :default)
      @id = id
      @frustration = 0
      @emotion = emotion.to_sym
   end

   #--------------------------------------------------------------------------
   # * Retourne l'event relié au Pawn
   #--------------------------------------------------------------------------
   def event
      Character_Utils.get(@id)
   end

   #--------------------------------------------------------------------------
   # * Déplace vers un caractère
   #--------------------------------------------------------------------------
   def move_to(goal)
      event.move_toward_character(goal)
   end

   #--------------------------------------------------------------------------
   # * Tourne en direction d'un caractère
   #--------------------------------------------------------------------------
   def turn_to(goal)
      event.turn_toward_character(goal)
   end

   #--------------------------------------------------------------------------
   # * Compare 2 evenement (cf Game_Character)
   #--------------------------------------------------------------------------
   def compare_to(other, goal)
      self.event.compare_distance(other.event, goal.id)
   end

   #--------------------------------------------------------------------------
   # * Donne la vitesse d'un event
   #--------------------------------------------------------------------------
   def speed
      event.move_speed
   end

   #--------------------------------------------------------------------------
   # * Attribue la vitesse d'un event
   #--------------------------------------------------------------------------
   def speed=(ns)
      event.move_speed = ns
   end

end

#==============================================================================
# ** Kernel
#------------------------------------------------------------------------------
#  Ajoute des outils de manipulation des pawn
#==============================================================================

module Kernel

   #--------------------------------------------------------------------------
   # * Accès public des méthodes
   #--------------------------------------------------------------------------
   extend self

   #--------------------------------------------------------------------------
   # * Crée un Pawn avec une "émotion"
   #--------------------------------------------------------------------------
   def event(id, emotion = :default)
      Pawn.new(id, emotion)
   end

   #--------------------------------------------------------------------------
   # * Fait vibrer un caractère
   #--------------------------------------------------------------------------
   def buzz(id, amplitude = 0.1, duration = 30, periode = 30)
      if SceneManager.scene_is?(Scene_Map)
         if $game_player.respond_to?(:buzz=)
            event = Character_Utils.get(id)
            event.buzz = duration
            event.buzz_length = duration
            event.buzz_amplitude = amplitude
            return true
         end
      end
      return false
   end


end

#==============================================================================
# ** Game_Group
#------------------------------------------------------------------------------
#  Déscription d'un groupe
#==============================================================================

class Game_Group

   #--------------------------------------------------------------------------
   # * Méthodes propre à la classe
   #--------------------------------------------------------------------------
   class << self

      #--------------------------------------------------------------------------
      # * Liste des comportemments
      #--------------------------------------------------------------------------
      def behaviours
         [:normal, :ghost, :teleport, :jump]
      end

      #--------------------------------------------------------------------------
      # * Défini si un symbole est un comportemment
      #--------------------------------------------------------------------------
      def behaviour?(var)
         behaviours.include?(var.to_sym)
      end

   end

   #--------------------------------------------------------------------------
   # * Accesseurs / Mutateurs
   #--------------------------------------------------------------------------
   attr_reader :members, :id
   attr_accessor :lost_distance, :leader, :type, :decal, :dash

   #--------------------------------------------------------------------------
   # * Constructeur
   #--------------------------------------------------------------------------
   def initialize(id, lost_distance, decal, type, leader, *complement)
      @id = id
      @dash = true
      @leader = Pawn.new(leader)
      @lost_distance = lost_distance
      @decal = decal
      @type = :normal
      @type = type if Game_Group.behaviour?(type)
      @members = []
      self.add(*complement)
   end

   #--------------------------------------------------------------------------
   # * Attribue un type
   #--------------------------------------------------------------------------
   def type=(type)
      @type = type.to_sym if Game_Group.behaviour?(type)
   end

   #--------------------------------------------------------------------------
   # * Redéfini le leader
   #--------------------------------------------------------------------------
   def leader=(id)
      unless id
         @members << @leader
         @leader = nil
         return true
      end
      potential_index = @members.find{|member|member.id == id}
      unless potential_index
         @members << @leader
         @leader = Pawn.new(id)
         return true
      end
      if potential_index
         @members << @leader
         @leader = @members[potential_index]
         @members[potential_index] = nil
         @members.compact!
         return true
      end
      return false
   end

   #--------------------------------------------------------------------------
   # * Retourne un membre en fonction de son ID
   #--------------------------------------------------------------------------
   def member(id)
      @members.find{|member| member.id == id}
   end

   #--------------------------------------------------------------------------
   # * Ajoute des membres
   #--------------------------------------------------------------------------
   def add(*members)
      members.each do |member|
         $game_map.groups.each do |group|
            if group
               if group.id != @id
                  group.remove(member) if group.member_exists?(member)
               end
            end
         end
         to_add = (member.is_a?(Pawn)) ? member : Pawn.new(member)
         to_add.speed = @leader.speed
         find = @members.find{|elt| elt.id == to_add.id} if @members
         @members << to_add unless find
      end
   end

   #--------------------------------------------------------------------------
   # * Retire des membres
   #--------------------------------------------------------------------------
   def remove(*members)
      members.each do |member|
         index = @members.index{|elt| elt.id == member}
         @members.delete_at(index)
      end
      @members.compact!
   end

   #--------------------------------------------------------------------------
   # * Nettoie le groupe
   #--------------------------------------------------------------------------
   def clear
      @members = []
   end
   
   #--------------------------------------------------------------------------
   # * Détruit un groupe
   #--------------------------------------------------------------------------
   def delete
      $game_map.groups.delete_at(@id)
   end

   #--------------------------------------------------------------------------
   # * Fonction utilitaire : Retourne le personnage le plus proche du meneur
   #  avant le membre ID
   #--------------------------------------------------------------------------
   def prec(id)
      return @leader.event if id == 0
      @members[id-1].event
   end

   #--------------------------------------------------------------------------
   # * Exécute les déplacements
   #--------------------------------------------------------------------------
   def update
      return nil unless @leader
      @members.sort!{|e1, e2| e1.compare_to(e2, @leader) }
      @members.compact!
      @members.each do |member|
         index = @members.index(member)
         fl = (@type == :ghost && member.event.distance_to(self.prec(index)) > @lost_distance)
         ll =  !$game_map.passable?(member.event.x, member.event.y, member.event.direction)
         member.event.through =  fl || ll
         if (@type == :teleport || @type == :jump) &&  member.event.distance_to(@leader.id) > @lost_distance + @members.length
            if @type == :teleport
               member.event.moveto(@leader.event.x, @leader.event.y)
            else
               route = RPG::MoveRoute.new()
               x = (@leader.event.x - member.event.x)
               y = (@leader.event.y - member.event.y)
               route.list = [RPG::MoveCommand.new(14,[x, y])]
               route.wait = true
               member.event.force_move_route(route)
            end
            member.event.turn_toward_character(@leader.event)
         end
         if !member.event.moving? and (member.event.distance_to(self.prec(index))) > @decal
            member.move_to(@leader.event)
            member.move_to(self.prec(index)) unless member.event.move_succeed
         else
            if member.emotion == :nervousness
               ra = Kernel.rand(2)
               if ra == 1 && !member.event.moving? && member.event.distance_to(@leader.event) > 1
                  member.move_to(@leader.event)
                  member.move_to(self.prec(index)) unless member.event.move_succeed
               end
            end
         end
         if member.event.distance_to(@leader.event) >= @lost_distance+(@members.length)
            rb = Kernel.rand(100)
             if rb >= 95 && member.emotion != :none
               member.event.balloon_id = Pawn.emoticone(member.emotion)
               member.frustration += 1
            end
            buzz(member.id) if rb >= 90 && member.emotion != :nervousness
            if member.emotion == :nervousness && rb > 90
               route = RPG::MoveRoute.new()
               route.list = [RPG::MoveCommand.new(14,[0, 0])]
               route.wait = true
               member.event.force_move_route(route)
               member.speed = @leader.speed
            end
         end
      end
   end

   #--------------------------------------------------------------------------
   # * Vérifie si un membre existe dans le groupe
   #--------------------------------------------------------------------------
   def member_exists?(id)
      return 0 unless @members
      @members.count{|member| member.id == id} > 0 || @leader.id == id
   end

   #--------------------------------------------------------------------------
   # * Vérifie si un membre est perdu
   #--------------------------------------------------------------------------
   def missed?(id)
      member(id).event.distance_to(@leader.event) >= @lost_distance+(@members.length)
   end

   #--------------------------------------------------------------------------
   # * Calcul le nombre de membres manquants
   #--------------------------------------------------------------------------
   def miss_people
      total = @members.count do |member|
         missed?(member.id)
      end
      total
   end

   #--------------------------------------------------------------------------
   # * Vérifie si le groupe est complet
   #--------------------------------------------------------------------------
   def complete?
      miss_people == 0
   end

   #--------------------------------------------------------------------------
   # * Vérifie si le groupe peut courrir
   #--------------------------------------------------------------------------
   def dash?
      @dash
   end

end

#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
#  Ajoute la gestion des groupes
#==============================================================================

class Game_Map

   #--------------------------------------------------------------------------
   # * alias
   #--------------------------------------------------------------------------
   alias consolidator_setup setup
   alias consolidator_update update

   #--------------------------------------------------------------------------
   # * Accesseurs / Mutateurs
   #--------------------------------------------------------------------------
   attr_accessor :groups

   #--------------------------------------------------------------------------
   # * Initialisation de la carte
   #--------------------------------------------------------------------------
   def setup(map_id)
      @groups = []
      consolidator_setup(map_id)
   end

   #--------------------------------------------------------------------------
   # * Mise à jours de la carte
   #--------------------------------------------------------------------------
   def update(main = false)
      @groups.each do |group|
         group.update if group
      end
      consolidator_update(main)
   end

   #--------------------------------------------------------------------------
   # * Récupère un groupe
   #--------------------------------------------------------------------------
   def group(id)
      return @groups[id]
   end

   #--------------------------------------------------------------------------
   # * Ajoute un groupe
   #--------------------------------------------------------------------------
   def add_group(id, lose, decal, type, leader, *members)
      @groups[id] = Game_Group.new(id, lose, decal, type, leader, *members)
   end
end

#==============================================================================
# ** Game_Interpreter
#------------------------------------------------------------------------------
#  Ajoute les fonctionnalités des groupes
#==============================================================================

class Game_Interpreter

   #--------------------------------------------------------------------------
   # * Crée un groupe
   # id = identifiant du groupe
   # lose = Distance max avant qu'un event soit perdu
   # decal = Le décalage positionnel des membres
   # leader = Id du leader
   # *members = liste des membres
   #--------------------------------------------------------------------------
   def create_group(id, lose, decal, type, leader, *members)
      $game_map.add_group(id, lose, decal, type, leader, *members)
   end

   #--------------------------------------------------------------------------
   # * Crée un groupe simplement avec des paramètres par défaut
   # id = identifiant du groupe
   # leader = Id du leader
   # *members = liste des membres
   #--------------------------------------------------------------------------
   def create_simple_group(id, leader, *members)
      $game_map.add_group(id, Config_Consolidator::DEFAULT_LOST_ZONE, Config_Consolidator::DEFAULT_DECAL,:normal, leader, *members)
   end

   #--------------------------------------------------------------------------
   # * Recupère un groupe (pour lui appliquer des transformations)
   #--------------------------------------------------------------------------
   def group(id)
      return $game_map.group(id)
   end

end

Vidéos
Vidéo 1 qui montre le regroupement ghost et le regroupement par téléportation
Vidéo 2 qui montre le regroupement par saut.

Bonne utilisation.

Mise à jours du code ?
Pour être tenu au courant de l'évolution du script 's'il y en a'
https://github.com/Funkywork/Scripts-rm/blob/master/VXAce/Groupeur-event.rb

XHTMLBoy - http://funkywork.blogspot.com

C'est cool ça, dommage que je sois sur XP ><*

Merci du partage !

Tu devrais mettre en avant tes vidéos, elles sont très rigolotes et bien démonstratives !

J'espère que tu trouveras des utilisateurs !

Merci à vous.
Premier message édité avec une nouvelle version du script et une nouvelle notice par Ulis ! Merci à elle !

Génial, j'avais déjà pensé à ce genre de script mais je suis une huitre dans ce domaine ! Donc merci, c'est un bon script ça.