Comme Wawower passait me voir sur msn pour me parler de mon script particuleur, je me suis dit que j'avais envie de republier une chtite version d'un autre script, probablement mon préféré. Voici le groupeur :

http://www.youtube.com/watch?v=wRa7J6XPdkM
(Y a-t-il un moyen d'afficher du streaming ici ? Sinon suivez le lien.)


J'en suis l'auteur. Il s'agit de ma version personnelle d'une chenille. Elle permet entre autre de ne pas fixer l'ordre des membres de l'équipes et de gérer intelligemment les collisions pour que l'on puisse parler à ses suiveurs.

Les instruction sont au début du script.
L'essentiel est que pour former un groupe constitué des evts 1,2,4 et 6 et mené par le joueur, on tapera, en "insérer script" :

Code: Tout sélectionner

grouper 0,1,2,4,6

Voici la version 3.8, encore jamais publiée. Elle ne se limite pas à grouper les personnages, comme le montre la vidéo, mais propose également des formations en rang, en pointe, en carré, etc. Toutefois c'est le groupe qui me tiens à coeur.

Code: Tout sélectionner

#Nom : Groupeur
#Version : 3.8
#Auteur, concepteur et demandeur : Fabien
#But : Soit l'équipe suit le meneur mais sans imiter le moindre de ses mouvements,
#      soit l'équipe est disciplinée est adopte une formation dérrière le meneur
#========================================================
# Le code n'est pas commenté, cela pour se faire si besoin.

#--Fct d'interfaces----------------------------------------------------------------
# Pour former un groupe constitué des evts 1,2,4 et 6 et mené par le joueur, on tapera:
# grouper 0,1,2,4,6
def grouper(meneur=0,*groupe)
  $game_map.groupeur.meneur=meneur
  $game_map.groupeur.groupe=groupe.to_a
end
# Une autre possibilité existe : ajoutez le mot mené à la fin du nom de l'event.
# Il sera ajouté à la map dès le chargement de celle-ci.
#------------------------------------------------------------------
# Pour faire manoeuvrer ce groupe, par exemple en pointe, il faudra rajouter :
# manoeuvrer Pointe
def manoeuvrer(formation,param=nil)
   $game_map.groupeur.formation=formation
   $game_map.groupeur.param=param
end
# liste des formations possibles :
# Liberté, Groupe, Chenille, ChenillePIX, Ligne, Rang, Pointe
# Cercle, Cercle_tournant, Front, Dents, Rectangle, Losange, Reunion
#------------------------------------------------------------------
def groupe # fct utile pour des fcts plus avancées.
  return [$game_map.groupeur.meneur]+$game_map.groupeur.groupe
end
#------------------------------------------------------------------

#Formations préprogrammées :
Liberté=nil
Groupe="déplacer_en_groupe"
Chenille="déplacer_en_chenille"
ChenillePIX='déplacer_en_chenille_pix'
Ligne=proc{|n,vx,vy,param| [vx*n,vy*n] }
Rang=proc{|n,vx,vy,param|m=(1+n)/2; [vx*m+(-vy.abs)**n,(-vx.abs)**n+vy*m] }
Pointe=proc{|n,vx,vy,param|m=(1+n)/2; [vx*m+m*(-vy.abs)**n,m*(-vx.abs)**n+vy*m] }
Cercle=proc{|n,vx,vy,param|
  param=(groupe.size-1)/3.1415 if param==nil
  phase=n*2*3.1415/(groupe.size-1)
  [param*Math.cos(phase),param*Math.sin(phase)] }
Cercle_tournant=proc{|n,vx,vy,param|
  param=(groupe.size-1)/3.1415 if param==nil
  phase=Graphics.frame_count/50.0+n*2*3.1415/(groupe.size-1)
  [param*Math.cos(phase),param*Math.sin(phase)] }
Front=proc{|n,vx,vy,param|m=(1+n)/2;vy=vy.abs;vx=vx.abs; [vy*m*(-vy.abs)**n,vx*m*(-vx.abs)**n] }
Dents=proc{|n,vx,vy,param|param=1 if param==nil ;m=(1+n)/2;vy=vy.abs;k=n/param;vx=vx.abs; [vy*m*(-vy.abs)**k+(-vx.abs)**m,vx*m*(-vx.abs)**k+(-vy.abs)**m] }
Rectangle=proc{|n,vx,vy,param|
  param==nil ? (l,d=3,0) : (l,d=param)
  n+=l-1;[vy*(n%l)+vx*(n/l)-vy*l/2+vx*d,vx*(n%l)+vy*(n/l)-vx*l/2+vy*d] }
Losange=proc{|n,vx,vy,param| n-=1;quart=groupe.size/4;
  param=quart if param==nil; m=n%quart; k=n/quart ; k%=4
  [m*[1,-1,-1,1][k]+param*[0,1,0,-1][k],m*[1,1,-1,-1][k]+param*[-1,0,1,0][k]] }
Reunion=proc{|n,vx,vy,param|
  [nil,  [-2*vy+vx,-2*vx+vy], [vy+vx,vy+vx], [-vy,-vx],
  [2*vx,2*vy],[2*vx-vy,2*vy-vx]][n]  }
#==classe principale============================================================
class Groupeur
  attr_accessor :groupe, :meneur, :formation, :param
  #--------------------------------------------------
  def initialize(groupe=[],meneur=0,formation=Groupe,param=nil)
    @groupe=groupe.to_a
    @meneur=meneur
    @formation=formation
    @param=param
  end
  #--------------------------------------------------
  def maj
    if @formation.is_a? Proc
      déplacer_en_formation
    elsif @formation.is_a? String
      eval @formation
    end
  end
end

  #--------------------------------------------------
#====fct des formations=========================================================
class Groupeur
  #--------------------------------------------------
  def déplacer_en_groupe
    menés = détermination_des_menés#détermination des menés
    (0...menés.size).each{|n| #on va déplacer chacun des menés
      meneur= ev(@meneur)
      distance=menés[n][0]
      evt=menés[n][1]
      #il marche vers le héros s'il en est trop loin et pas en train de bouger
      evt.move_toward_player if distance > 46+n*32 and not evt.moving?
      next
      #s'il est trop loin, passe-mur...
      @thread_guide=nil if @thread_guide !=nil and @thread_guide.status==false
      if distance > 146+n*32 and @thread_guide==nil         
          @thread_guide=Thread.new {
          $options_guide[5]=true ;
          evt.va(meneur.x,meneur.y,n+1) ;
          $options_guide[5]=false}         
      end   }
  end
  #---------------------------------------------------
  def détermination_des_menés     
      meneur=ev(@meneur)#détermination du meneur
      #détermination des menés :
      menés=Hash.new # on va les stocker dans un Hash
      for id in @groupe # pour chaque id donné on trouve
        evt=ev(id) #l'evt correspondant
        distance=Math.hypot(  #sa distance au meneur
                 evt.screen_x-meneur.screen_x,evt.screen_y-meneur.screen_y)
        menés[distance]=evt # on stocke ces deux informations dans le hash
        evt.move_speed=meneur.move_speed #alignement de vitesse de marche
        evt.colisions
      end
      menés=menés.sort# on range les menés par ordre de distance
      return menés
    end   
#-------------------------------------------------------
def déplacer_en_chenille
  @param=[] if not @param.is_a?(Array) or not @param[0].is_a?(Array)
  (@groupe+[@meneur]).each{|mené|@param.push [ev(mené).x,ev(mené).y] }  if @param.empty?
  meneur=ev(@meneur)
  pos=[meneur.x,meneur.y]
  if @param[0] != pos
    @param.pop
    @param.unshift(pos)
  end
  for n in 0...@groupe.size
    evt=ev(@groupe[n])
    evt.move_speed=meneur.move_speed
    evt.colisions
    x,y=@param[n+1]
    evt.move_toward(x,y)
  end
end
#-------------------------------------------------------
def pos(id)
  resu=[ev(id).real_x,ev(id).real_y,ev(id).direction,ev(id).pattern,""]
  return resu
end
#-------------------------
def ini_param(espace)
  liste=[]
  grp=[@meneur]+@groupe
  (0...grp.size-1).each{|n|
    pos0=pos(grp[n])
    pos1=pos(grp[n+1])
    dx=(pos1[0]-pos0[0])/espace.to_f
    dy=(pos1[1]-pos0[1])/espace.to_f
    espace.times {
      liste.push pos0.clone
      pos0[0]+=dx
      pos0[1]+=dy } }
  espace.times { liste.push pos(grp[-1]) }
@param=liste
end
#-------------------------
def déplacer_en_chenille_pix
  espace=10
  @param=[] if not @param.is_a?(Array) or not @param[0].is_a?(Array)
  ini_param(espace)  if @param.empty?
  meneur=ev(@meneur)
  if @param[0] != pos(@meneur)
    @param.pop
    @param.unshift(pos(@meneur))
    arret=false
  else
    arret=true
  end
  for n in 0...@groupe.size
    evt=ev(@groupe[n])
    evt.move_speed=meneur.move_speed
    evt.colisions
   
    pos=@param[(n+1)*espace]
    if pos[0]=="debarquer"
      ev(pos[1][n+1]).debarquer
      evt.jump(0,0)
      next
    end
    x,y,dir,pattern=pos
   
    pattern=meneur.pattern if arret
    evt.real_x=x
    evt.real_y=y

    evt.direction=dir
    evt.pattern=pattern
  end
end
#----------------------------------------------------------
def déplacer_en_formation
    meneur=ev(@meneur)
    vect_x,vect_y=[[1,-1],[0,-1],[-1,-1],[-1,0],[0,0],[1,0],[-1,1],[0,1],[1,1]][meneur.direction-1]
    for n in 0...@groupe.size
      evt= ev (@groupe[n])
      evt.colisions
      n+=1

      dx,dy=@formation[n,-vect_x,vect_y,@param]
      x = meneur.x + dx.round
      y = meneur.y + dy.round
      evt.move_speed=meneur.move_speed
      evt.move_speed+=1 if (evt.x-x).abs >1  or (evt.y-y).abs >1
      evt.direction=meneur.direction if evt.move_toward(x,y) and not evt.moving?
    end
  end
#--------------------------------------------------------------
end
#outils
#===Section permettant au héros de traverser les suiveurs=======================
class Game_Character
  attr_accessor :through ,:mémo_through ,:direction
  def colisions
  if (Input.trigger?(Input::LEFT) and @x+1==ev.x and @y==ev.y  and $game_player.direction==4)
      @through=true
      $game_player.move_left
      move_right
      @through=false
  end
  if (Input.trigger?(Input::RIGHT) and @x-1==ev.x and @y==ev.y  and $game_player.direction==6)
      @through=true
      $game_player.move_right
      move_left
      @through=false
   end
   if (Input.trigger?(Input::UP) and @x==ev.x and @y+1==ev.y  and $game_player.direction==8)
      @through=true
      $game_player.move_up
      move_down
      @through=false
   end     
   if (Input.trigger?(Input::DOWN) and @x==ev.x and @y-1==ev.y  and $game_player.direction==2)
      @through=true
      $game_player.move_down
      move_up
      @through=false
   end
end
#----deux fonctions RM mais vers des coords--------------------------
def move_toward(x,y)
    sx = @x - x
    sy = @y - y   
    return true if sx == 0 and sy == 0
    abs_sx,abs_sy = sx.abs,sy.abs
    rand(2) == 0 ? abs_sx += 1 : abs_sy += 1  if abs_sx == abs_sy
    if abs_sx > abs_sy
      sx > 0 ? move_left : move_right
      sy > 0 ? move_up : move_down if not moving? and sy != 0
    else
      sy > 0 ? move_up : move_down
      sx > 0 ? move_left : move_right if not moving? and sx != 0
    end
    return false
  end
#------------------------------------------------------------   
  def move_away_from(x,y)
    sx = @x - x
    sy = @y - y
    return if sx == 0 and sy == 0     
    abs_sx,abs_sy = sx.abs,sy.abs
    rand(2) == 0 ? abs_sx += 1 : abs_sy += 1 if abs_sx == abs_sy
    if abs_sx > abs_sy
      sx > 0 ? move_right : move_left
      sy > 0 ? move_down : move_up  if not moving? and sy != 0
    else
      sy > 0 ? move_down : move_up     
      sx > 0 ? move_right : move_left if not moving? and sx != 0
    end
  end
#-------------------------------------------------
end
#===================================================
def ev(id=0) # synthaxe super abrégée pour désigner un evenement
  return (id==0 ? $game_player: $game_map.events[id])
end
#==Groupe de base===================================
class Game_Map
  attr_accessor :groupeur
  alias setup_groupeur setup
  def setup(map_id)
    @groupeur=Groupeur.new
    setup_groupeur(map_id)
    @a=1
  end
  alias update_groupe update
  def update     
    if @a==1
      groupe_p=$game_map.groupeur.groupe.clone
      groupe_p.unshift(0) if not groupe_p.include?(0)     
#      placer2(groupe_p,ev.x,ev.y,ev.direction) # si vous avez le script de débordeur activez cette ligne     
      @a=nil
    end   
   
    update_groupe # fonction d'origine
    @groupeur.maj
  end
end
#==Auto-ajout par 'menés'=============================

class Game_Event
  attr_accessor :real_x, :real_y, :direction, :pattern
  alias initialize_groupeur initialize
  def initialize(map_id, event)
    initialize_groupeur(map_id, event)       
    $game_map.groupeur.groupe.push(@id) if event.name[-5..-1]=="mené" and
        @page != nil and @character_name != ""
  end
end