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