Ce script est une amélioration du "groupeur" pour RPG Maker VX proposé par s4suk3.
ObjectifIl 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.
![[VXace] Consolidator Groupe10](https://i.servimg.com/u/f42/16/32/35/96/groupe10.png)
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.
![[VXace] Consolidator Groupe11](https://i.servimg.com/u/f42/16/32/35/96/groupe11.png)
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 plusLa 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).
![[VXace] Consolidator Groupe12](https://i.servimg.com/u/f42/16/32/35/96/groupe12.png)
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.
InstallationCopiez/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 !
UtilisationL'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 groupeLa 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 groupeUne 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 courseDans 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 membresIl 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éosVidé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