Solide glissant sur un rail (part I,II)

[Anonyme]

C'est du bon boulot , le problème des jeux de plate forme , c'est le système de tuilles , on ne peut pas stocké la courbe de chaque tuile à l'écran dans un tableau , trop gourmand en ram , il faut utilisé des formules de math à la place , comme des courbes de bezier par exemple.

[Huitbit]

@Cpl. Bator
En fait, je ne connais pas trop Sonic !

Quand c'est sorti, il fallait une console et j'en avais pas
Je l'ai vu tourner !

Y a-t-il un site où on peut essayer une version fidèle à l'esprit d'origine du jeu (si possible sans passer par un émulateur) ? Comme ça, je pourrai me faire une idée du gameplay.

Pour l'instant, je suis tombé sur des versions pas terribles (site http://www.caiman.us).

De tout façon, en se creusant un peu la tête, on doit être capable de trouver des astuces pour passer des tiles aux courbes(même si la méthode est différente de celle des concepteurs du jeu )!

Hasta la vista !

[beauregard]

@Cpl. Bator
En fait, je ne connais pas trop Sonic !

mario contre sonic, la belle époque...
"Le système de macro est une fonctionnalité très puissante, principalement utile pour les programmeurs chevronnés." ah je vois que c'est mieux en effet...

un beau moteur physique pour notre pb d'amour:
http://www.purebasic.fr/english/viewtopic.php?t=31022

pour compiler les sources, alors il faut placer les 2 lib (chipmunk et chipmunkd) dans le dossier win32 et chipmunk_Import.pbi dans le dossier Imports( tout çà dans le dossier Includes) ET le dossier Includes, ouf !

lancé chipmunkDemoMain et contempler... puis appuyer sur la touche 1, 2, 3, ou 4... et là c'est la fête au village

[Anonyme2]

Très bon Huitbit

[beauregard]

eddy nous a concocté un autre code qui déchire:
http://www.purebasic.fr/english/viewtop ... ht=#251600

[Anonyme]

a mon avis , il faut associer des courbes à des images qui serviront de tiles.
ex, un tile avec un plan droit , on trace une droite , en fait , tu charges la courbe en fonction du tile rencontrer ( méthode box collision )...

Le sonic timetwisted se raproche beaucoup de l'original à 2 / 3 truc près... ( cf: le lien que tu files )

[Frenchy Pilou]

pour compiler les sources, alors il faut placer les 2 lib (chipmunk et chipmunkd) dans le dossier win32 et chipmunk_Import.pbi dans le dossier Imports( tout çà dans le dossier Includes) ET le dossier Includes, ouf !

Ne peux-tu pas faire le fichier final résultant?
là c'est un peu déroutant
Je n'ai que l'escalier

[comtois]

dans le lien ci dessus ,j'ai repéré un jeu de GPI , l'auteur de JaPBe !
entièrement écrit en PureBasic, d'ailleurs les sources sont dispos sur son site

http://www.caiman.us/scripts/fw/f1251.html

[Huitbit]

Merci pour les liens !

@Cpl. Bator

à mon avis , il faut associer des courbes à des images qui serviront de tiles.

C'est un peu comme ça que je voyais les choses !
Par contre, comme prévu, des cercles, des droites, des sinus !
Un petit écran, ça fait moins de pixels à gérer.

Le scrolling est impressionnant !

@Frenchy Pilou
+1

Voilà en attendant ma piste d'essai pour la prochaine mise à jour:

Code : Tout sélectionner

;solide guidé motorisé
;pb v4.20
;auteur Huitbit
;*********************************
#largeur_ecran=1024
#hauteur_ecran=768
#dim_sprite=32
Enumeration
  #spr_decor
  #spr_car_droite
  #spr_car_gauche
EndEnumeration
Structure donnees
  x.f
  y.f
  dx.f
  dy.f
  s.f ; abscisse curviligne s(t)
  cosinus.f; cosinus de l'angle vecteur poids |P> et le vecteur tangent à la courbe
  phi_radian.f ;angle correspondant à la pente locale de la courbe, en radians
EndStructure
x_car.f=100
y_car.f=480
vx_car.f
vy_car.f
acceleration_moteur.f
#acceleration_moteur_max=8
#dt=0.2
#coeff_frot=0.1
spr_car.b
#g=9.8


;création de la piste
Dim courbe.donnees(5000)
#y_depart=64
e.f=2.718281828 ; valeur de exp(1)
#parametre_gaussienne=0.001
#parametre_bosse=0.0004
#hauteur_bosse=64
t.w = 0 ;paramètre pour les fonctions x(t), y(t) et s(t) sur tout le parcours
t_max.w ; dernière valeur de t
p.w = 0 ; paramètre provisoire pour chaque portion de courbes
x_point_precedent.f=0
y_point_precedent.f=#y_depart
angle.w
#rayon=100
longueur_courbe.f = 0

s.f ; abscisse curviligne s(t)
s_max.w ; abscisse curviligne s(t) maximale
int_s.w; valeur entière de s(t)
vs.f ; vitesse curviligne 
angle_rotation.w

;première demi-gaussienne
While courbe(t)\x<#largeur_ecran/8
  t=t+1
  p=p+1
  courbe(t)\x=p
  courbe(t)\y=#y_depart+(#hauteur_ecran*2/3-#y_depart)*(1-Pow(e,-#parametre_gaussienne*p*p))
  courbe(t)\dx=1
  courbe(t)\dy=(#hauteur_ecran*2/3-#y_depart)*#parametre_gaussienne*2*p*Pow(e,-#parametre_gaussienne*p*p)
  longueur_courbe=longueur_courbe+Sqr(courbe(t)\dx*courbe(t)\dx+courbe(t)\dy*courbe(t)\dy)
  courbe(t)\s=longueur_courbe
  courbe(t)\cosinus=courbe(t)\dy / Sqr(courbe(t)\dx*courbe(t)\dx+courbe(t)\dy*courbe(t)\dy) 
  courbe(t)\phi_radian =ATan(courbe(t)\dy/courbe(t)\dx)
  
Wend
t_max=t

; portion horizontale n°1
While courbe(t)\x<0.25*#largeur_ecran
  t=t+1
  p=p+1
  courbe(t)\x=p
  courbe(t)\y=courbe(t_max)\y
  courbe(t)\dx=1
  courbe(t)\dy=0
  longueur_courbe=longueur_courbe+Sqr(courbe(t)\dx*courbe(t)\dx+courbe(t)\dy*courbe(t)\dy)
  courbe(t)\s=longueur_courbe
  courbe(t)\cosinus=courbe(t)\dy / Sqr(courbe(t)\dx*courbe(t)\dx+courbe(t)\dy*courbe(t)\dy) 
  courbe(t)\phi_radian =ATan(courbe(t)\dy/courbe(t)\dx)
  
Wend
t_max=t


;bosse
While courbe(t)\x<#largeur_ecran/2
  t=t+1
  p=p+1
  courbe(t)\x=p
  courbe(t)\y=courbe(t_max)\y-#hauteur_bosse*Pow(e,-#parametre_bosse*(p-3*#largeur_ecran/8)*(p-3*#largeur_ecran/8))
  courbe(t)\dx=1
  courbe(t)\dy=#hauteur_bosse*2*#parametre_bosse*(p-3*#largeur_ecran/8)*Pow(e,-#parametre_bosse*(p-3*#largeur_ecran/8)*(p-3*#largeur_ecran/8))
  longueur_courbe=longueur_courbe+Sqr(courbe(t)\dx*courbe(t)\dx+courbe(t)\dy*courbe(t)\dy)
  courbe(t)\s=longueur_courbe
  courbe(t)\cosinus=courbe(t)\dy / Sqr(courbe(t)\dx*courbe(t)\dx+courbe(t)\dy*courbe(t)\dy) 
  courbe(t)\phi_radian =ATan(courbe(t)\dy/courbe(t)\dx)
  
Wend
t_max=t


; portion horizontale n°2
While courbe(t)\x<0.75*#largeur_ecran
  t=t+1
  p=p+1
  courbe(t)\x=p
  courbe(t)\y=courbe(t_max)\y
  courbe(t)\dx=1
  courbe(t)\dy=0
  longueur_courbe=longueur_courbe+Sqr(courbe(t)\dx*courbe(t)\dx+courbe(t)\dy*courbe(t)\dy)
  courbe(t)\s=longueur_courbe
  courbe(t)\cosinus=courbe(t)\dy / Sqr(courbe(t)\dx*courbe(t)\dx+courbe(t)\dy*courbe(t)\dy) 
  courbe(t)\phi_radian =ATan(courbe(t)\dy/courbe(t)\dx)
  
Wend
t_max=t


;cercle 
For angle=0 To 360
  t=t+1
  courbe(t)\x=courbe(t_max)\x+#rayon*Cos(#PI*(-angle+90)/180); décalage de 90° pour partir du bon endroit sur l'ellipse !
  courbe(t)\y=courbe(t_max)\y-#rayon+#rayon*Sin(#PI*(-angle+90)/180)
  courbe(t)\dx=#rayon*#PI/180*Sin(#PI*(-angle+90)/180)
  courbe(t)\dy=-#rayon*#PI/180*Cos(#PI*(-angle+90)/180)
  longueur_courbe=longueur_courbe+Sqr(courbe(t)\dx*courbe(t)\dx+courbe(t)\dy*courbe(t)\dy)
  courbe(t)\s=longueur_courbe
  courbe(t)\cosinus=courbe(t)\dy / Sqr(courbe(t)\dx*courbe(t)\dx+courbe(t)\dy*courbe(t)\dy) 
  courbe(t)\phi_radian =ATan(courbe(t)\dy/courbe(t)\dx)
  
Next angle
t_max=t

;deuxième demi-gaussienne
While courbe(t)\x<#largeur_ecran-1
  t=t+1
  p=p+1
  courbe(t)\x=p
  courbe(t)\y=courbe(t_max)\y-(#hauteur_ecran*2/3-#y_depart)*Pow(e,-#parametre_gaussienne*(p -#largeur_ecran)*(p -#largeur_ecran))
  courbe(t)\dx=1
  courbe(t)\dy=(#hauteur_ecran*2/3-#y_depart)*2*#parametre_gaussienne*(p -#largeur_ecran)*Pow(e,-#parametre_gaussienne*(p -#largeur_ecran)*(p -#largeur_ecran))
  longueur_courbe=longueur_courbe+Sqr(courbe(t)\dx*courbe(t)\dx+courbe(t)\dy*courbe(t)\dy)
  courbe(t)\s=longueur_courbe
  courbe(t)\cosinus=courbe(t)\dy / Sqr(courbe(t)\dx*courbe(t)\dx+courbe(t)\dy*courbe(t)\dy) 
  courbe(t)\phi_radian =ATan(courbe(t)\dy/courbe(t)\dx)
  
Wend
t_max=t

;correspondance s<===>(x,y)
s_max=Round(longueur_courbe,#PB_Round_Nearest)
Dim t_correspondant.l(s_max);tableau qui va permettre de faire le lien entre abscisse curviligne s et coordonnées cartésiennes x,y par le biais du paramètre t
; à chaque valeur de s on va faire correspondre une valeur t
For int_s=1 To s_max
  For i=1 To t_max
    If int_s=Round(courbe(i)\s,#PB_Round_Nearest)
      t_correspondant(int_s)=i
    EndIf
  Next i
Next int_s

For int_s=1 To s_max
  If  t_correspondant(int_s)=0
    t_correspondant(int_s)=t_correspondant(int_s-1)
  EndIf
Next int_s

InitSprite()
InitSprite3D()
InitKeyboard()
OpenWindow(0,0,0,#largeur_ecran,#hauteur_ecran,"solide guidé motorisé | <= et => pour se déplacer !",#PB_Window_ScreenCentered|#PB_Window_SystemMenu  )
OpenWindowedScreen(WindowID(0),0,0,#largeur_ecran,#hauteur_ecran,0,0,0)

CreateSprite(#spr_decor,1024,768)
StartDrawing(SpriteOutput(#spr_decor))
For t=1 To t_max
  LineXY(x_point_precedent, y_point_precedent, courbe(t)\x, courbe(t)\y,RGB(0,255,255))
  x_point_precedent.f=courbe(t)\x
  y_point_precedent.f=courbe(t)\y
Next t
FillArea(10,600,RGB(0,255,255),RGB(0,55,55))
StopDrawing()

CreateSprite(#spr_car_droite,32,32,#PB_Sprite_Texture)
StartDrawing(SpriteOutput(#spr_car_droite))
Box(0,4,16,12,RGB(75, 241, 75))
Ellipse(16,16,16,12,RGB(248, 241, 7))
Circle(8,24,8,RGB(15, 109, 240))
Circle(24,26,6,RGB(15, 109, 240))
Box(20,11,6,5,RGB(174, 192, 248))
StopDrawing()
CreateSprite3D(#spr_car_droite, #spr_car_droite)

CreateSprite(#spr_car_gauche,32,32,#PB_Sprite_Texture)
StartDrawing(SpriteOutput(#spr_car_gauche))
Box(16,4,16,12,RGB(75, 241, 75))
Ellipse(16,16,16,12,RGB(248, 241, 7))
Circle(24,24,8,RGB(15, 109, 240))
Circle(8,26,6,RGB(15, 109, 240))
Box(6,11,6,5,RGB(174, 192, 248))
StopDrawing()
CreateSprite3D(#spr_car_gauche, #spr_car_gauche)

s=600
t=t_correspondant(Int(s))

Repeat
  Repeat
    Event = WindowEvent()      
    If  Event = #PB_Event_CloseWindow
      End 
    EndIf
  Until Event = 0
  
  
  ExamineKeyboard()
  If KeyboardPushed(#PB_Key_Left)
    acceleration_moteur=acceleration_moteur-2
    If acceleration_moteur<-#acceleration_moteur_max
      acceleration_moteur=-#acceleration_moteur_max
    EndIf
  ElseIf  KeyboardPushed(#PB_Key_Right)
    acceleration_moteur=acceleration_moteur+2
    If acceleration_moteur>#acceleration_moteur_max
      acceleration_moteur=#acceleration_moteur_max
    EndIf
  Else 
    acceleration_moteur=0
  EndIf
  
  ;-équations du mouvement
  vs=vs+(#g*courbe(t)\cosinus-#coeff_frot*vs+acceleration_moteur)*#dt
  s=s+vs*#dt
  If s<1
    s=1
  EndIf
  If s>s_max
    s=s_max
  EndIf
  
  
  ;recherche de la valeur de t
  t=t_correspondant(Int(s))
  
  angle_rotation=180*courbe(t)\phi_radian /#PI 
  If courbe(t)\dx<0 
    angle_rotation=angle_rotation+180
  EndIf
  ;choix du sprite en fonction du sens de parcours
  If vs >=0 
    spr_car=#spr_car_droite
  Else
    spr_car=#spr_car_gauche
  EndIf
  
  
  DisplaySprite(#spr_decor,0,0)
  Start3D()
  RotateSprite3D(spr_car,angle_rotation,0)
  DisplaySprite3D(spr_car,courbe(t)\x-16,courbe(t)\y-16)
  Stop3D()
  
  Delay(1)
  FlipBuffers() 
ForEver

Hasta la vista !

[Anonyme]

Peut on couplé ce code avec ton modèle de chute libre ? ( si on s'arrête en haut du looping ? )

[Huitbit]

C'est l'objet de la prochaine mise à jour !
La bosse, elle, pourra servir de tremplin à condition que la vitesse soit suffisante .
Idem pour les parois, possibilité de décrochage.

(Je ferai un code un peu plus "propre" )

Patience !

[Anonyme]

Je suis en train d'étudier tes codes , tel que c'est , c'est impossible de couplé tout ca avec des tiles , car , c'est une unique courbe.

Code : Tout sélectionner

Dim courbe.donnees(5000) 

Chaque tile dois disposé de sa prorpre courbe , dans ce style :



mais a partir de l'image , comment je calcule le reste de la structure données ?

Structure donnees
x.f
y.f
dx.f
dy.f
s.f ; abscisse curviligne s(t)
cosinus.f; cosinus de l'angle vecteur poids |P> et le vecteur tangent à la courbe
phi_radian.f ;angle correspondant à la pente locale de la courbe, en radians
EndStructure

je peut remplir x & y , mais après ? dx,dy,s,cosinus,phi_radian sont encore mystique pour moi

[Huitbit]

Rien de mystique dans la dérivé
C'est juste une version améliorée du coefficient directeur d'une droite.

En tout cas, si tu connais x et y tu peux tout trouver !

Il y a différentes méthodes de calcul à partir de séries de valeurs.
Ci-dessous :
f(t)= 3*t²
théoriquement df(t)/dt=6*t
avec la méthode numérique [df(t)/dt](i) = { [f(t)](i+1)-[f(t)](i-1) }/ { [t](i+1)-[t](i-1)}




Si tu as dx(t)/dt et dy(t)/dt tu auras phi et
le cosinus avec les formules qui sont déjà dans le code !

Fais des essais avec un tableur !

Si tu arrives à faire le lien avec les tiles alors CHAMPAGNE !

Hasta la vista !

(Je vais un peu vite car je n'ai pas trop le temps, désolé )

[beauregard]

là c'est un peu déroutant
Je n'ai que l'escalier

appui sur la touche 2 ou 3 ou 4 correspondant chacune à une demo.
Suite de l'aventure, forum jeu:
http://www.purebasic.fr/french/viewtopic.php?t=8338

Je suis en train d'étudier tes codes , tel que c'est , c'est impossible de couplé tout ca avec des tiles , car , c'est une unique courbe.

Chaque tile dois disposé de sa prorpre courbe

l'image de la courbe, que tu vas afficher à l'emplacement X et Y du tile, ne doit pas forcement être de la même taille de ce tile.

Voilà en attendant ma piste d'essai pour la prochaine mise à jour

une piste d'essai interactive qui plus est !

[Frenchy Pilou]

hihi
Je m'obstinais sur le clavier numérique alors que c'était les touche numérique du clavier normal