terrain 2D vu de côté (worms) alléatoire !

[Thyphoon]

je voudrais faire un terrain en 2D aléatoire
de ce genre là

j'ai trouvé un algo qui m'a l'air pas mal ici=>
http://gamedev.stackexchange.com/questi ... generation
en gros si je comprends bien

Il faut Créer un point au milieu de l'écran, avec une hauteur aléatoire
Nous avons donc maintenant deux sections
je divise en deux chaque sections avec un point au milieu d' une hauteur au hasard entre ses deux voisins Répéter n fois.
en gros ça donne ça



mon problème je ne sais pas comment faire pour faire ça simplement !
quelqu'un aurait une idée ?

[graph100]

tu fais ça avec des listes chainée je pense.
J'y réfléchi ^^

[Thyphoon]

tu fais ça avec des listes chainée je pense.
J'y réfléchi ^^

Merci c'est sympa,c'est ce que j'essaye de faire, mais j'ai pas le résultat voulu

Code : Tout sélectionner

;-Generate Terrain

NewList MapA()
NewList MapB()
max=500
min=0
marge=100

AddElement(MapA()):MapA()=Random(500)+min ;point le plus a gauche
AddElement(MapA()):MapA()=Random(500)+min ;point au centre
AddElement(MapA()):MapA()=Random(500)+min ;point le plus a droite
For n=0 To 5;  je subdivise 10 fois
ClearList(MapB())
For z=0 To ListSize(MapA())-2
  SelectElement(MapA(),z)
  a=MapA()
  SelectElement(MapA(),z+1)
  b=MapA()
  AddElement(MapB()):MapB()=a
  If a>b
    delta=(a-b)/2
    new=b+Random(delta)+delta
  Else
    delta=(b-a)/2
    new=a+Random(delta)+delta
  EndIf
  AddElement(MapB()):MapB()=new
Next

CopyList(MapB(),MapA())
Next

et apres on utilise la liste MapA() pour tracer le terrain

mais ça me fait des lignes droites presque a chaque fois ... bref pas le resultat escompté

je besoin de ce terrain pour un jeu du style artillerie ! 2 joueurs, chaqu'un sa tour ! on regle l'angle et la force du canon et on essaye de détruite le tour de l'autre ... c'est plus sympa dans un terrain montagneux !

[Thyphoon]

voilà, c'est pas finit mais c'est déjà mieux !!! mais je trouve ça trop simpliste comme relief ...

Code : Tout sélectionner

InitSprite()

InitKeyboard()

If OpenWindow(0,0,0,800,600,"A screen in a window... using gadget and sprites!",#PB_Window_SystemMenu|#PB_Window_SizeGadget|#PB_Window_ScreenCentered)
  OpenWindowedScreen(WindowID(0),0,0,800,600,0,0,0)
EndIf
;-Generate Terrain

NewList MapA()
NewList MapB()
AddElement(MapA()):MapA()=Random(400)+100
AddElement(MapA()):MapA()=10;point au centre
AddElement(MapA()):MapA()=Random(400)+100
For n=0 To 6;  je subdivise 10 fois
  ClearList(MapB())
  For z=0 To ListSize(MapA())-2
    SelectElement(MapA(),z)
    a=MapA()
    SelectElement(MapA(),z+1)
    b=MapA()
    AddElement(MapB()):MapB()=a
    If a>b
      delta=Abs(a-b)/2
      new=b+Random(delta)+delta
    Else
      delta=Abs(b-a)/2
      new=a+Random(delta)+delta
    EndIf
    AddElement(MapB()):MapB()=new
  Next
  AddElement(MapB()):MapB()=b
  CopyList(MapB(),MapA())
Next

Repeat
  Event.l = WindowEvent()     
  FlipBuffers()       ; Inverse the buffers (the back become the front (visible)... and we can do the rendering on the back
  ClearScreen(0)
  
  ExamineKeyboard()
  
  StartDrawing(ScreenOutput())
  w=800/ListSize(MapA())
  ForEach MapA()
    Circle(ListIndex(MapA())*w,MapA(),5,#Green)
  Next
  StopDrawing()
  Delay(1)
  
Until Event = #PB_Event_CloseWindow Or KeyboardPushed(#PB_Key_Escape)

End  

[G-Rom]

C'est très simple à faire, tu génère un bitmap avec un bruit de perlin :


Tu peut additionner le résultat avec un autre bitmap de ce type ( si tu veut une ile centrale par exemple ) :


En additionnant les deux cela donne :


Puis tu lis la valeur sur une ligne de l'image ( au milieu par exemple ) :


Tu lis la valeur de chaque pixel :
Value = (Red + Green + Blue ) / 3
Value contient donc une valeur entre 0 et 255 , que tu peut multiplier par un facteur de ton choix pour avoir la hauteur final.

un post qui pourrais t'intéresser :
http://www.sfml-dev.org/forum-fr/viewtopic.php?t=3628

@++

[Thyphoon]

merci beaucoup G-Rom ! je vais voir ça de suite !

[graph100]

voila j'ai fini

touche :
[Entre] : Régénère la carte
[Droite] [Gauche] : change le paramètre de rugosité et régénère la carte


Je ne me suis surtout pas attardé sur des détails

Code : Tout sélectionner

;{ structure & variables

Structure adr_tache
	*left.i
	*right.i
EndStructure

Structure ciel_partie
	largeur.d
	couleur.l
EndStructure

Structure etoile
	x.d
	y.d
	
	pulse.d
	offset.d
EndStructure


#w = 800
#h = 600

NewList sol()
Define rugosite.d = 2

NewList ciel.ciel_partie()

NewList etoile.etoile()
Global etoile_max.l, etoile_min.l

;}


;{ procedure

Macro Random_min_max(min, max)
	Random(max - min) + min
EndMacro

Procedure GenereTerrain(taille_mini, taille_max, largeur, rugosite.d, List terrain())
	Protected tmp.adr_tache
	Protected NewList tache.adr_tache()
	Protected NewList tmp_tache.adr_tache()
	
	ClearList(terrain())
	
	; on initialise la liste de traitement des elements (évite la récursivité)
	AddElement(tache())
	
	
	; on créer les éléments frontières
	; limite gauche
	AddElement(terrain())
	terrain() = Random_min_max(taille_mini, taille_max)
	tache()\left = @terrain()
	
	; limite droite
	AddElement(terrain())
	terrain() = Random_min_max(taille_mini, taille_max)
	tache()\right = @terrain()
	
	; init du range
	range = (taille_max - taille_mini) / 2
	
	For a = 3 To largeur
		FirstElement(tache())
		CopyStructure(tache(), @tmp, adr_tache)
		
		; on ajoute l'élément milieu
		ChangeCurrentElement(terrain(), tmp\left)
		AddElement(terrain())
		
		terrain() = (PeekL(tmp\left) + PeekL(tmp\right)) / 2 + Random(range) - range / 2
		
		AddElement(tmp_tache())
		tmp_tache()\left = tmp\left
		tmp_tache()\right = @terrain()
		
		AddElement(tmp_tache())
		tmp_tache()\left = @terrain()
		tmp_tache()\right = tmp\right
		
		DeleteElement(tache())
		
		; réduction du range
		If ListSize(tache()) = 0
			CopyList(tmp_tache(), tache())
			ClearList(tmp_tache())
			
			range / rugosite
		EndIf
		
	Next
	
EndProcedure


Procedure Degrade(couleur1, couleur2, pourcentage.d)
	r.d = Red(couleur1) * pourcentage + Red(couleur2) * (1 - pourcentage)
	g.d = Green(couleur1) * pourcentage + Green(couleur2) * (1 - pourcentage)
	b.d = Blue(couleur1) * pourcentage + Blue(couleur2) * (1 - pourcentage)
	
	ProcedureReturn RGB(r, g, b)
EndProcedure

Procedure InitCiel(nb_partie, hauteur_du_ciel.l, couleur_haute, couleur_basse, List ciel.ciel_partie())
	ClearList(ciel())
	
	For a = 1 To nb_partie
		AddElement(ciel())
		ciel()\largeur = hauteur_du_ciel / nb_partie
		
		ciel()\couleur = Degrade(couleur_basse, couleur_haute, a / nb_partie)
	Next
	
EndProcedure

Procedure Ciel_mouvement(offset.d, hauteur_du_ciel.l, List ciel.ciel_partie())
	
	pas.d = 2 * #PI / ListSize(ciel())
	
	ForEach ciel()
		ciel()\largeur = ((1 + Sin(ListIndex(ciel()) * pas + offset)) / (2 * #PI)) * hauteur_du_ciel
	Next
	
EndProcedure


Procedure InitEtoile(nb.l, h_mini, h_maxi, largeur.l, List flocon.etoile())
	
	etoile_max = h_maxi
	etoile_min = h_mini
	
	For a = 1 To nb
		AddElement(flocon())
		
		flocon()\y = Random_min_max(h_mini, h_maxi)
		flocon()\x = Random(largeur)
		
		flocon()\offset = Random(2000 * #PI) / 1000
		flocon()\pulse = Random(2000 * #PI) / 1000
	Next
EndProcedure


;}


;{ initialisation

If InitSprite() = 0 Or InitKeyboard() = 0
	End
EndIf

;}


;{ ouverture de la fenetre

If OpenWindow(0, 0, 0, #w, #h, "", #PB_Window_ScreenCentered | #PB_Window_SystemMenu)
	If OpenWindowedScreen(WindowID(0), 0, 0, WindowWidth(0), WindowHeight(0), 0, 0, 0) = 0
		End
	EndIf
	
Else
	End
EndIf

KeyboardMode(1)

;}

;{ init divers

; init du ciel
InitCiel(20, #h, RGB(0, 128, 128), RGB(206, 231, 231), ciel())

offset.d = 0
Ciel_mouvement(offset, #h, ciel())

; init des flocon / etoile
InitEtoile(100, 0, 400, #w, etoile())


; init du terrain
GenereTerrain(100, #h - 100, #w, rugosite, sol())

;}


;{ boucle principale

Repeat
	Delay(20)
	event = WindowEvent()
	ExamineKeyboard()
	
	;{ touches
	
	If KeyboardPushed(#PB_Key_Escape) : event = #PB_Event_CloseWindow : EndIf
	
	If KeyboardReleased(#PB_Key_Return)
		GenereTerrain(100, #h - 100, #w, rugosite, sol())
	EndIf
	
	If KeyboardPushed(#PB_Key_Left)
		rugosite - 0.1
		GenereTerrain(100, #h - 100, #w, rugosite, sol())
	EndIf
	
	If KeyboardPushed(#PB_Key_Right)
		rugosite + 0.1
		GenereTerrain(100, #h - 100, #w, rugosite, sol())
	EndIf
	
	
	;}
	
	
	;{ dessin
	
	ClearScreen(#White)
	
	If StartDrawing(ScreenOutput())
		;{ dessin du ciel
		
		offset + 0.002
		Ciel_mouvement(offset, #h, ciel())
		
		y = 0
		ForEach ciel()
			Box(0, y, #w, ciel()\largeur, ciel()\couleur)
			
			y + ciel()\largeur
		Next
		
		;}
		
		;{ dessin des flocons
		
		ForEach etoile()
			etoile()\offset = etoile()\offset + 0.0001 + Random(10) / 1000
			etoile()\pulse + 0.001 + Random(10) / 1000
			
			etoile()\y + Random(10) / 100
			etoile()\x + Sin(etoile()\offset) / 5
			
			If etoile()\y > etoile_max
				etoile()\y = etoile_min
				etoile()\x = Random(#w)
				
				etoile()\offset = Random(2000 * #PI) / 1000
				etoile()\pulse = 0
			EndIf
			
			Box(etoile()\x, etoile()\y, 3 * Sin(etoile()\pulse), 3 * Sin(etoile()\pulse), #White)
		Next
		
		;}
		
		;{ dessin du sol
		ForEach sol()
			LineXY(ListIndex(sol()), sol(), ListIndex(sol()), #h, #Black)
		Next
		;}
		
		StopDrawing()
	EndIf
	
	FlipBuffers()
	
	;}
	
Until event = #PB_Event_CloseWindow

;}

End

(pssst : essaye de mettre des codes propres xD, le premier que tu as posté me donne des frissons )

[Backup]

je reprends ton algo

1 diviser l'ecran en tranche (x_pos() )
2 etablir pour chaque point de la division une hauteur aléatoire (y_pos() )

Code : Tout sélectionner

 tranche=30 ; defini le nombre de tranche dans l'ecran
hauteur_aleatoire=5 ; defini l'aleatoire (la decoupe)


If InitSprite() = 0
      MessageRequester("Erreur", "Impossible d'ouvrir l'écran & l'environnement nécessaire aux sprites !", 0)
      End
EndIf
 
If OpenWindow(0, 0, 0, 220, 160, "Un écran dans une fenêtre...", #PB_Window_SystemMenu | #PB_Window_ScreenCentered)
      ButtonGadget(0, 170, 135, 45, 20, "Quitter")
      
      If OpenWindowedScreen(WindowID(0), 0, 0, 160, 160, 0, 0, 0)
            x=160 / tranche ; on divise l'ecrant en x tranches
            Y=160/2 ; au centre horizontale
            Dim x_pos(tranche-1)
            Dim y_pos(tranche-1)
            For i=0 To tranche-1
                  x_pos(i)= x
                  x=x+(160 / tranche)
                  y_pos(i)=Y+Random(hauteur_aleatoire)
            Next i
      EndIf
      
      
      Repeat
            ; Il est très important de traiter tous les événements restants dans la file d'attente à chaque tour
            ;
            Repeat
                  Event = WindowEvent()
                  
                  Select Event
                        Case #PB_Event_Gadget
                              If EventGadget() = 0
                                    End
                              EndIf
                              
                        Case #PB_Event_CloseWindow
                              End
                  EndSelect
            Until Event = 0
            
            
            StartDrawing(ScreenOutput())
                  mem_x=0:mem_y=160/2
                  For i=0 To tranche-1
                        LineXY(mem_x,mem_y,x_pos(i),y_pos(i),RGB(255,255,255))
                        mem_x=x_pos(i)
                        mem_y=y_pos(i)
                  Next i
                  
            StopDrawing()
            FlipBuffers()
            ClearScreen(RGB(0, 0, 0))
            
      ForEver
EndIf

bon ... trop tard tu as eu le temps de poster avant moi

[graph100]

C'est pas grave, on t'aime quand même
En plus, plus il y a d'exemple, mieux c'est.

Je tiens quand même à préciser que je n'ai pas utiliser l'algo dont il parle (on divise en 2 sections etc...) car il ne donne pas le résultat de l'image
Je suis aller sur le lien qu'il a donnée, et j'ai utilisé l'algorithme de déplacement du point milieu (midpoint displacement algorithm)

[Thyphoon]

merci graph100 et Dobro ! c'est très sympa de votre part !
je vais etudier comment vous avez fait !

(pssst : essaye de mettre des codes propres xD, le premier que tu as posté me donne des frissons )

Oui désolé j'étais prit part le temps,et je voulais laissé l'impression que je vous demandais une solution sans avoir chercher !

promis je ferais plus attention aux codes que je poste !

[graph100]

(pssst : essaye de mettre des codes propres xD, le premier que tu as posté me donne des frissons )

Oui désolé j'étais prit part le temps,et je voulais laissé l'impression que je vous demandais une solution sans avoir chercher !

Bah la pour le coup, mon code devrais te convenir

promis je ferais plus attention aux codes que je poste !

Chouette ^^, quand je répond c'est que le sujet m'interresse assez pour m'y investir ^^
Mais j'ai énormément de mal à "rentrer" dans le code des autres. C'est une des raisons pour lesquelles j'ai essayé de changer ma façon de programmer (si tu regardes les 1ers code que j'ai posté en 2005, c'est juste dégeux et moi-même je me hais pour ça )

[Huitbit]

Hello,

Sinon, il y a ça (bruit de perlin et subdivision de courbes) :
(Posté dans : http://www.purebasic.fr/french/viewtopi ... +perlin+2D)



La courbe rouge correspond au résultat final.

Code : Tout sélectionner

;Perlin&Subdivisions
;Auteur Huitbit
;Février 2011
;PureBasic 4.51 (Windows  -  x86)
; *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  * 
#LargeurEcran = 800
#HauteurEcran = 600
#NbreDeSubdivisions = 3
#OctaveMax = 5
#Persistance = 0.4
Octave.b 
Persistance.f
#NombreInitialDePtsDeCtrl = 8
IndiceMaxTableau.l 
TailleTableau.l = ((#NombreInitialDePtsDeCtrl*Pow(2,#OctaveMax - 1) - 2) * Pow(2,#NbreDeSubdivisions) + 1) 
RapportSubdv.f = 0.25
FacteurNormalisation.f =(1 - Pow(#Persistance,#OctaveMax)) / (1 - #Persistance)
Bruit1DNormeA.f
Bruit1DNormeB.f

Structure InfosPoint
  x.l
  y.l ; y  =  a  *  x  + b
  a.f ; pente
  b.f ; ordonnée à l'origine
EndStructure

Macro affine(a,b,uA,zA,uB,zB)
If (uB-uA)<>0
  a = (zB - zA) / (uB - uA)
  b = zB - a * uB 
EndIf
EndMacro


; - ######################################
; - PROGRAMME PRINCIPAL
; - ######################################

InitSprite()
InitKeyboard()
OpenWindow(0,0,0,#LargeurEcran,#HauteurEcran,"Test Perlin 1D    Tapez F1 pour créer une nouvelle courbe",#PB_Window_ScreenCentered|#PB_Window_SystemMenu  )
OpenWindowedScreen(WindowID(0),0,0,#LargeurEcran,#HauteurEcran,0,0,0)

;- label pour le Goto, tracé d'une nouvelle courbe
NouvelleCourbe :
;- tableau des points de la courbe

Dim P.InfosPoint (TailleTableau,#OctaveMax)
Dim Bruit1D.l(1024)

For Octave = 1 To #OctaveMax
  NombreDePtsDeCtrl = #NombreInitialDePtsDeCtrl *Pow(2,Octave - 1)
  IndiceMaxTableau = ((NombreDePtsDeCtrl - 2) * Pow(2,#NbreDeSubdivisions) + 1) ;pour avoir le nombre de points, ajouter 1 à l'indice !
  
  Persistance = Pow(#Persistance,Octave - 1) 
  ;initialisation des points de contrôle
  ;Départ et arrivée
  P(0,Octave)\x = 0
  P(0,Octave)\y = 0
  P(NombreDePtsDeCtrl - 1,Octave)\x = #LargeurEcran
  P(NombreDePtsDeCtrl - 1,Octave)\y = P(0,Octave)\y
  
  ;Autres points
  For i = 1 To NombreDePtsDeCtrl - 2
    P(i,Octave)\x = i * #LargeurEcran / (NombreDePtsDeCtrl - 1)
    P(i,Octave)\y = Random(255)*Persistance
  Next i
  
  
  ;- subdivisions de la courbe
  For SubdivisionEnCours = 0 To #NbreDeSubdivisions - 1
    IndiceMaxProvisoire = (NombreDePtsDeCtrl - 2) * Pow(2,SubdivisionEnCours) + 1
    For i = IndiceMaxProvisoire - 1 To 1 Step  - 1
      
      If i = IndiceMaxProvisoire - 1
        P(2 * i + 1,Octave)\x = #LargeurEcran
        P(2 * i + 1,Octave)\y = P(0,Octave)\y 
        P(2 * i,Octave)\x = P(i,Octave)\x + RapportSubdv * (P(i + 1,Octave)\x - P(i,Octave)\x)
        P(2 * i,Octave)\y = P(i,Octave)\y + RapportSubdv * (P(i + 1,Octave)\y - P(i,Octave)\y)
        
      Else
        P(2 * i + 1,Octave)\x = P(i,Octave)\x + (1 - RapportSubdv) * (P(i + 1,Octave)\x - P(i,Octave)\x)
        P(2 * i + 1,Octave)\y = P(i,Octave)\y + (1 - RapportSubdv) * (P(i + 1,Octave)\y - P(i,Octave)\y)
        P(2 * i,Octave)\x = P(i,Octave)\x + RapportSubdv * (P(i + 1,Octave)\x - P(i,Octave)\x)
        P(2 * i,Octave)\y = P(i,Octave)\y + RapportSubdv * (P(i + 1,Octave)\y - P(i,Octave)\y)
      EndIf
      
    Next i
    
    P(1,Octave)\x = P(0,Octave)\x + (1 - RapportSubdv) * (P(1,Octave)\x - P(0,Octave)\x)
    P(1,Octave)\y = P(0,Octave)\y + (1 - RapportSubdv) * (P(1,Octave)\y - P(0,Octave)\y)
    
  Next SubdivisionEnCours
  
  ;-calculs des équations affines de chaque segment
  For i = 0  To IndiceMaxTableau - 1
    affine(P(i,Octave)\a,P(i,Octave)\b,P(i,Octave)\x,P(i,Octave)\y,P(i + 1,Octave)\x,P(i + 1,Octave)\y)
  Next i
  
  
  CreateSprite(Octave,#LargeurEcran,#HauteurEcran)
  StartDrawing(SpriteOutput(Octave))
  For i = 0 To IndiceMaxTableau - 1
    LineXY(P(i,Octave)\x,#HauteurEcran - P(i,Octave)\y,P(i + 1,Octave)\x,#HauteurEcran  - P(i + 1,Octave)\y ,RGB(0,50 + Octave*30,255 ))
  Next i
  StopDrawing()
Next Octave

;-Bruit1D, somme de toutes les octaves

For Octave = 1 To #OctaveMax
  NombreDePtsDeCtrl = #NombreInitialDePtsDeCtrl *Pow(2,Octave - 1)
  IndiceMaxTableau = ((NombreDePtsDeCtrl - 2) * Pow(2,#NbreDeSubdivisions) + 1) ;pour avoir le nombre de points, ajouter 1 à l'indice !
  x = 0
  For i = 0 To IndiceMaxTableau - 1
    
    While x < P(i+1,Octave)\x 
      Bruit1D(x) = Bruit1D(x) + P(i,Octave)\a * x + P(i,Octave)\b
      x = x + 1
    Wend
    
  Next i
Next Octave
Bruit1D(#LargeurEcran) = Bruit1D(0)
CreateSprite(#OctaveMax+1,#LargeurEcran,#HauteurEcran)
StartDrawing(SpriteOutput(#OctaveMax+1))
For x= 0 To #LargeurEcran - 1  
  Bruit1DNormeA = #HauteurEcran - Bruit1D(x) / FacteurNormalisation 
  Bruit1DNormeB = #HauteurEcran - Bruit1D(x + 1) / FacteurNormalisation 
  LineXY(x, Bruit1DNormeA, x + 1, Bruit1DNormeB,RGB(255,0,0))
Next x
  
StopDrawing()

;- ######################################
;- BOUCLE PRINCIPALE
;- ######################################
Repeat
  ;- affichage
  FlipBuffers() 
  For Octave = 1 To #OctaveMax
    DisplayTransparentSprite(Octave,0,0)
  Next Octave
  DisplayTransparentSprite(#OctaveMax + 1,0,0)
  
  
  Delay(1)
  
  ExamineKeyboard()
  If KeyboardReleased(#PB_Key_F1)
         ClearScreen(RGB(0,0,0))
     Goto NouvelleCourbe
  EndIf
  
Until WindowEvent()  =  #PB_Event_CloseWindow 

Hasta la vista !

[Thyphoon]

Bah la pour le coup, mon code devrais te convenir

tout a fait !

C'est une des raisons pour lesquelles j'ai essayé de changer ma façon de programmer (si tu regardes les 1ers code que j'ai posté en 2005, c'est juste dégeux et moi-même je me hais pour ça )

je crois qu'on est tous un peu comme ça, c'est ce que j'aime dans la programmation on apprend en permanence ! tu fais un code tu es content de toi... tu le refais 1 ans apres et il est déjà différent, mieux ecrit, et tu te dis je pourrais pas faire mieux. Mais 1 ans encore apres si tu recommence tu refais mieux ....ect....

Hello,
Sinon, il y a ça (bruit de perlin et subdivision de courbes) :
Hasta la vista !

Harrg super Huibit ! pourtant j'avais chercher sur le forum bruit de perlin mais j'avais trouvé que des codes pour la 3D
un grand merci !

[Huitbit]

Hello,

De rien, je viens de voir un truc inutile :
Un boucle qui ne servait à rien !

Après correction :

Code : Tout sélectionner

ExamineKeyboard()
  If KeyboardReleased(#PB_Key_F1)
         ClearScreen(RGB(0,0,0))
     Goto NouvelleCourbe
  EndIf

Pour les premier et dernier pics, je les ai forcés à zéro mais ils peuvent être quelconques (voir code 3D).

Par contre pour Perlin, contrairement à ce code, il vaut mieux dissocier la génération des pics du lissage. Comme ça, tu peux utiliser la méthode que tu veux pour le lissage, il y en a plein !
J'ai essayé les subdivisions car c'est rapide pour la génération de terrains 3D.
Mais pour un terrain 2D, ça sera toujours rapide.

Pour la 3D, j'ai encore des optimisations de prévues...

Hasta la vista !

[Thyphoon]

merci je vais regarder ça !!