Consolidator VXAce

Messages : 25

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.
Consolidator VXAce Groupe10

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.
Consolidator VXAce Groupe11

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).

Consolidator VXAce Groupe12

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

Un grand merci à Ulis pour sa patiente relecture de la notice.

Messages : 2

c'est assez lon mais tres utile merci Normal

» VXACE
» [VXAce]Pop up Item
» [VXAce]WoL: Prologue
» VxAce : Les codes dans les messages !
» [VXAce]A la croisée des chemins (Complet)