essai plateforme

comtois · Message par **comtois** » ven. 11/févr./2005 22:05

encore un truc qui risque de trainer longtemps sur mon disque avant que je n'y retouche :

http://perso.wanadoo.fr/comtois/sources/plateforme.zip

il faut la lib de Paul "Vbin" pour lancer le source .
http://www.pureproject.net/

si ça intéresse quelqu'un pour le reprendre qu'il ne se gêne pas

morukutsu · Message par **morukutsu** » ven. 19/août/2005 11:36

Euh, UP !

T'aurais pas une version qui marche avec la derniere version de Vbin ?

comtois · Message par **comtois** » ven. 19/août/2005 15:48

Essaye avec cette lib ,ça devrait fonctionner.

http://perso.wanadoo.fr/comtois/sources/VBin_Lib

Anonyme · Message par **Anonyme** » sam. 20/août/2005 1:16

La lib fait planté le compilateur. je pense que c'est peut etre du au manque des fichier .chm qui vont avec.

@++

comtois · Message par **comtois** » sam. 20/août/2005 5:49

j'ai fait des fouilles sur mon disque dur , et je pense que j'ai tout retrouvé.

http://perso.wanadoo.fr/comtois/images/SpritesForum.zip

voila , avec ça , vous pouvez soit utiliser directement les sprites non compressés en modifiant un peu le code , ou alors refaire une archive avec la dernière lib Vbin

Anonyme · Message par **Anonyme** » sam. 20/août/2005 10:33

Merci comtois.

morukutsu · Message par **morukutsu** » sam. 20/août/2005 23:40

Merci,
Sinon vous n'auriez pas le code source d'un jeu de plateforme 2D ? Car j'aimerais bien voir comment est geré le saut . J'ai regardé le code de Comtois mais j'ai pas tout compris .

Merci d'avance .

poshu · Message par **poshu** » dim. 21/août/2005 10:15

Moi, ce qui m'interesserais c'est une formule pour que le saut ressemble à quelques chose.... Je suppose qu'une fonction décrivrant une parabole sur Y en fonction de X (qui serait ici le temps) fonctionne, seulement, mes essais ont donné un résultat assez.... Particulier.

Merci d'avance

comtois · Message par **comtois** » dim. 21/août/2005 10:20

poshu a écrit :Moi, ce qui m'interesserais c'est une formule pour que le saut ressemble à quelques chose.... Je suppose qu'une fonction décrivrant une parabole sur Y en fonction de X (qui serait ici le temps) fonctionne, seulement, mes essais ont donné un résultat assez.... Particulier.

Merci d'avance

cherche le mot balistique , j'avais fait un truc de ce genre ?
ça tient aussi compte de la vitesse du vent , mais pas de l'âge du capitaine

djes · Message par **djes** » dim. 21/août/2005 10:43

Pfff! Ca me fait rire ces histoires de paraboles. Y'a pas besoin de maths pour ça!!!! Tu le fais avec des variables x,y et des vitesses qui décroivent.
Plus tard, quand tu seras un peu plus fort, tu feras une petite table contenant un sinus et ce sera parfait.

Edit : ortho

Anonyme · Message par **Anonyme** » dim. 21/août/2005 16:40

Voila , je viens de faire une p'tite maj du code.
plus besoin de la lib VBin1, ni de la 2.

Tout les graphismes doivent etre dans leurs dossiers respectif
"Sprite_PNGsave" dans "Sprite_PNG" etc...

il se peut que le débuggeur trouve une erreure, désactiver le.

++

Code : Tout sélectionner

;Comtois le 27/08/2004
;Essais jeu Plateforme 
UsePNGImageDecoder()

;- Declare les procédures
Declare ChargeObstacles()
Declare PositionMarqueurs()
Declare Collision()
Declare Erreur(Message$)

;{- Initialisation
#ScreenWidth  = 640
#ScreenHeight = 480
#ScreenDepth  = 32
If InitSprite() = 0 Or InitKeyboard() = 0 
  Erreur("Impossible d'initialiser DirectX 7 Ou plus")
ElseIf OpenScreen( #ScreenWidth , #ScreenHeight , #ScreenDepth , "Plateforme" ) = 0
  Erreur("Impossible d'ouvrir l'écran ")
EndIf
SetFrameRate(50)


;}
;{- Constantes
;/marqueurs
Enumeration
  #M_Sol
  #M_Sol1
  #M_Sol2
  #M_Sol3
  #M_Sol4
  #M_Sol5
  #M_Sol6
  #M_Sol7
  #M_BarriereG
  #M_BarriereD
  #M_PenteG
  #M_PenteD
  #M_HauteurG
  #M_HauteurD
  #M_VideG
  #M_videD
  #M_BalanceG
  #M_BalanceD
  #M_main
  #M_Rebord    
EndEnumeration  
;/Animation
Enumeration
  #SpArret
  #SpBalance
  #SpMarche
  #SpSaute
  #SpTombe
  #SpTir
  #SpAgrippe
  #SpRebondit  
  #SpBaisse
EndEnumeration
;/Etat du Gus
Enumeration
  #E_Normal
  #E_Agrippe
EndEnumeration  
;/ Sens Gus
  #Gauche      = 0
  #Droit       = 9          ; égal au nombre des animations
  #Haut        = #Droit * 2 ;  
  #Bas         = #Droit * 4 ; 
  #NbMarqueurs = 20
  #NbAnimation = 53         ; Nombre total des animations - 1 ( car on démarre à 0 )
  #FPS         = 1000/50    ; 50 images par seconde 
;}
;{- Structures
Structure Obstacle
  Sprite.l
  X.l
  Y.l
EndStructure  
Structure Marqueur
  Sprite.l
  X.l
  Y.l
  PChaudX.l                ; Point Chaud en X  => Point de référence pour l'affichage 
  PChaudY.l                ; Point Chaud en Y  => Point de référence pour l'affichage
  PActionX.l
  PActionY.l
  Collision.l
EndStructure  
Structure Animation
  Nom$                     ; Nom de l'animation 
  Sprite.l                 ; No du sprite utilisé pour l'animation
  ImageEnCours.l           ; No de l'image en cours
  ImageDebut.l             ; No de la première image de l'animation
  ImageFin.l               ; No de la dernière image de l'animation
  ImageBoucle.l            ; Si répétition = 0 , l'animation boucle sur cette image
  Repetition.l             ; 0 => l'animation boucle sur ImageBoucle , >0 => indique le nombre de répétition à réaliser 
  Compteur.l               ; Compteur répétition
  Taillex.l                ; Dimension en X de chaque image 
  TailleY.l                ; Dimension en Y de chaque image
  TempsEnCours.l           ; Durée d'affichage de l'image en cours
  TempsMaxi.l              ; Durée d'affichage d'une image
  PChaudX.l                ; Point Chaud en X  => Point de référence pour l'affichage 
  PChaudY.l                ; Point Chaud en Y  => Point de référence pour l'affichage
  PActionX.l               ; Point Action en X => Point de départ du tir ( ou d'une autre action )
  PActionY.l               ; Point Action en Y => Point de départ du tir ( ou d'une autre action )  
EndStructure 
Structure Gus
  Etat.l                   ; Etat du Gus ( Normal , Agrippé ...)
  Animation.l              ; Animation en cours
  Direction.l              ; Direction de l'animation , Haut ou bas ou horizontal ( gestion des pentes ) 
  Sens.l                   ; sens de l'animation , Gauche ou droit  
  No.l                     ; Numéro de l'animation en cours = Animation en cours + sens  
  X.l                      ; Position en X du sprite
  Y.l                      ; Position en Y du sprite
  PasX.l                   ; Vitesse déplacement horizontal
  FlagA.l                  ; Drapeau pour la gestion du saut
  FlagB.l                  ; gestion du saut 
  FlagSolA.l               ; Collision avec le sol
  Vie.l                    ; Compteur Vie
  Balle.l                  ; Compteur Balles
  Grenade.l                ; Compteur Grenade
  MemSaut.l                ; Mémoire touche saut , anti rebond 
EndStructure 
;} 
;{- Variables et initialisations
NewList Obstacle.Obstacle()
NewList Rebord.Obstacle()
Global Gus.Gus
Global ShowMarqueurs.l
Global ShowPalmiers.l
Global MEmMainX.l,MEmMainY.l ; Mémorise la position d'un rebord lors d'une collision avec la main
Dim Marqueur.Marqueur(#NbMarqueurs)
Dim AnimeGus.Animation(#NbAnimation)
Dim SpDecor(4)
Dim SpObstacle(1000) ; Je prévois large ,peut-être qu'une liste chainée serait plus adaptée ? à voir

;/ Initialise le gus
Gus\Animation = #SpTombe ; C'est presque inutile puisque le prog va se charger de gérer la bonne anime
Gus\Sens      = #Gauche
Gus\No        = Gus\Animation + Gus\Sens
Gus\FlagA     = 0
Gus\X         = 300
Gus\Y         = 0
Gus\PasX      = 3
Gus\Etat      = #E_Normal

;/ Lecture des obstacles et du décor
For i = 1 To 4
  Fichier$ = "Sprites_PNG\Palmier " + Str(i) + "_4.PNG"
  SpDecor(i) = LoadSprite(#PB_Any,Fichier$)
Next i  
ChargeObstacles() 


;/ Lecture Datas des marqueurs
Restore Marqueurs
For i = 0 To #NbMarqueurs - 1
  Read Nom$
  Read Marqueur(i)\PChaudX 
  Read Marqueur(i)\PChaudY 
  Read Marqueur(i)\PActionX
  Read Marqueur(i)\PActionY
  Marqueur(i)\Sprite = LoadSprite(#PB_Any,"Marqueurs\"+Nom$ + ".PNG")
    If Marqueur(i)\Sprite = 0
     Erreur("Chargement Marqueur => Marqueurs\" + Noms$)
  EndIf
 Next i 


;/Lecture Datas Animations 
Restore Animations
For i = 0 To #NbAnimation
  Read AnimeGus(i)\Nom$         
  Read AnimeGus(i)\ImageEnCours 
  Read AnimeGus(i)\ImageDebut   
  Read AnimeGus(i)\ImageFin     
  Read AnimeGus(i)\ImageBoucle  
  Read AnimeGus(i)\Repetition   
  Read AnimeGus(i)\Compteur    
  Read AnimeGus(i)\Taillex      
  Read AnimeGus(i)\TailleY      
  Read AnimeGus(i)\TempsEnCours 
  Read AnimeGus(i)\TempsMaxi    
  Read AnimeGus(i)\PChaudX      
  Read AnimeGus(i)\PChaudY      
  Read AnimeGus(i)\PActionX     
  Read AnimeGus(i)\PActionX    
  ;/Charge les sprites
  Fichier$ = "Sprites_PNG\" + AnimeGus(i)\Nom$ + ".png"
  
  ;LoadSprite(#PB_Any, Fichier$)
  AnimeGus(i)\Sprite = LoadSprite(#PB_Any,Fichier$)
  If AnimeGus(i)\Sprite = 0
    Erreur("Chargement Sprites => " + Fichier$)
  EndIf  
Next i
;}
;{- Procédures
Procedure Erreur(Message$)
  MessageRequester("Erreur",Message$,0)
  End
EndProcedure



;-obs
Procedure ChargeObstacles()
Restore Obstacles
idx=0
Repeat
  Read Fichier$
  If Fichier$<>""
  NoSprite = Val(Fichier$) 
  SpObstacle(NoSprite) = LoadSprite(#PB_Any,"Obstacles\"+Fichier$+".bmp")
  idx+1
  EndIf
Until Fichier$=""
EndProcedure



Procedure Niveau()
  ;If OpenFile(0, "Niveaux/Niveau.dat")
  Restore Niveau1
  For v = 8 To 14
      ;no$ = ReadString()
      For u = 0 To 19
       ; NoObstacle = Val(Mid(no$, u + 1, 1))
        Read NoObstacle
        If NoObstacle 
          AddElement(Obstacle())
          Obstacle()\Sprite = SpObstacle(NoObstacle)
          Obstacle()\X = u * SpriteWidth(Obstacle()\Sprite)
          Obstacle()\Y = v * SpriteHeight(Obstacle()\Sprite)
          ; Ajoute un Rebord aux extrémités des plateformes
          If NoObstacle = 74
            AddElement(Rebord())
            Rebord()\X = Obstacle()\X + 22
            Rebord()\Y = Obstacle()\Y + 8
          EndIf  
          If NoObstacle = 171
            AddElement(Rebord())
            Rebord()\X = Obstacle()\X 
            Rebord()\Y = Obstacle()\Y + 8
          EndIf  
        EndIf
      Next u
    Next v     
    ;CloseFile(0)
 ; Else
 ;   Erreur("Chargement niveau")
 ; EndIf
EndProcedure  
Procedure GestionClavier()
  If ExamineKeyboard()
    If Gus\Etat = #E_Normal  
      If KeyboardPushed(#PB_Key_Left)
           
        If Gus\FlagA < 99 And Marqueur(#M_BarriereG)\Collision = 0
          Gus\X - 3
        EndIf
        
        If Gus\FlagA = 99
          If KeyboardPushed(#PB_Key_LeftControl) = 0
            Gus\Animation = #SpMarche
          EndIf
          ;Gestion de la pente
          If Marqueur(#M_BarriereG)\Collision = 0
            If Gus\Direction = #Bas
              Gus\X - 2
              Gus\Y + 1
            ElseIf Gus\Direction = #Haut
              Gus\X - 2
              Gus\Y - 1
            Else
              Gus\X - 3
            EndIf  
          EndIf  
        EndIf  
        
        Gus\Sens = #Gauche
        
      ElseIf KeyboardPushed(#PB_Key_Right)
        
        If Gus\FlagA < 99 And Marqueur(#M_BarriereD)\Collision = 0
          Gus\X + 3    
        EndIf
        
        If Gus\FlagA = 99
          If KeyboardPushed(#PB_Key_LeftControl) = 0
            Gus\Animation = #SpMarche
          EndIf  
          
          ;Gestion de la pente
          If Marqueur(#M_BarriereD)\Collision = 0
            If Gus\Direction = #Bas
              Gus\X + 2
              Gus\Y + 1
            ElseIf Gus\Direction = #Haut
              Gus\X + 2
              Gus\Y - 1
            Else
              Gus\X + 3
            EndIf  
          EndIf  
        EndIf 
        
        Gus\Sens = #Droit
        
      ElseIf Gus\Animation = #SpMarche
        Gus\Animation = #SpArret
      EndIf
      
      If KeyboardPushed(#PB_Key_LeftShift) And Gus\FlagA = 99
        Gus\FlagA = -13
        Gus\Animation = #SpSaute
      EndIf
      If KeyboardPushed(#PB_Key_LeftControl) And Gus\Animation = #SpArret And Gus\FlagA = 99
        Gus\Animation = #SpTir
      ElseIf Gus\Animation = #SpTir And AnimeGus(#SpTir)\ImageEnCours = AnimeGus(#SpTir)\ImageFin
        Gus\Animation = #SpArret
      EndIf
      If KeyboardReleased(#PB_Key_F1) 
        ShowMarqueurs = 1 - ShowMarqueurs
      EndIf
    
    ElseIf Gus\Etat = #E_Agrippe
      If KeyboardPushed(#PB_Key_Down)  
        If Gus\Sens = #Gauche
          Gus\FlagA = -5
          Gus\Animation = #SpSaute
          Gus\X + 12
        Else
          Gus\FlagA = -5
          Gus\Animation = #SpSaute
          Gus\X - 12
        EndIf
        Gus\Etat = #E_Normal
      EndIf
      If KeyboardPushed(#PB_Key_LeftShift) 
        If Gus\MemSaut = 0
          Gus\MemSaut = 1
          Gus\FlagA = -11
          Gus\Animation = #SpSaute
          Gus\Etat = #E_Normal
        EndIf 
      Else
        Gus\MemSaut = 0
      EndIf
      PositionMarqueurs()
      Collision()
    EndIf
  EndIf
EndProcedure
Procedure AffPalmiers()
  For v = 0 To 3  
    NoSprite = SpDecor(v + 1)
    For u = 0 To 4 
      DisplaySprite(NoSprite, u * SpriteWidth(NoSprite), v * SpriteHeight(NoSprite))
    Next u
  Next v  
EndProcedure
Procedure AffMarqueurs()
  For i = 0 To #NbMarqueurs - 1
    ;If i = #M_PenteD Or i = #M_PenteG Or i = #M_Sol1
      DisplayTransparentSprite( Marqueur(i)\Sprite , Marqueur(i)\X, Marqueur(i)\Y)
    ;EndIf  
  Next i 
  ForEach Rebord()
    DisplaySprite(Marqueur(#M_Rebord)\Sprite, Rebord()\X, Rebord()\Y)
  Next  
EndProcedure
Procedure AfficheNiveau()

ForEach Obstacle()
  DisplayTransparentSprite(Obstacle()\Sprite, Obstacle()\X, Obstacle()\Y)
Next   
EndProcedure
Procedure PositionMarqueurs()
  For i = 0 To #NbMarqueurs - 2
    Marqueur(i)\X  = Gus\X - Marqueur(i)\PChaudX
    Marqueur(i)\Y  = Gus\Y - Marqueur(i)\PChaudY
  Next i  
EndProcedure
Procedure Collision()
  ;Faire un tableau map() 
  ;pour tester une Collision avec le Gus ,c'est inutile de tester tout le tableau , un encadrement autour du gus peut 
  ;suffire ! exemple tester  de - 1 à + 1 sprites par rapport à la position du Gus  , ça ne fera plus que 9 tests !!
  
  
  For i = 0 To #NbMarqueurs - 3
    Marqueur(i)\Collision = 0
  Next i  
  ForEach Obstacle()
    For i = 0 To #NbMarqueurs - 3
      Col =  SpritePixelCollision(Marqueur(i)\Sprite, Marqueur(i)\X, Marqueur(i)\Y, Obstacle()\Sprite, Obstacle()\X, Obstacle()\Y) 
      ;If i = #M_Sol And Col
      ;  Marqueur(i)\Collision = Obstacle()\no
      ;Else
        Marqueur(i)\Collision + Col
      ;EndIf  
    Next i  
  Next
EndProcedure  
Procedure CollisionMain()
  Marqueur(#M_main)\Collision = 0
  ;Si le Gus tombe ,il cherche à s'accrocher à un rebord 
  If Gus\FlagA > 0 
  ForEach Rebord()
    If  SpriteCollision(Marqueur(#M_main)\Sprite, Marqueur(#M_main)\X, Marqueur(#M_main)\Y, Marqueur(#M_Rebord)\Sprite, Rebord()\X, Rebord()\Y) 
      Marqueur(#M_main)\Collision = 1
      MEmMainX = Rebord()\X
      MEmMainY = Rebord()\Y
    EndIf  
  Next  
  EndIf
EndProcedure
Procedure Animation()
  Static OldNo
  Gus\No = Gus\Animation + Gus\Sens + Gus\Direction ; No de l'animation en cours 
  If OldNo <> Gus\No
    ; init l'animation  
    AnimeGus(OldNo)\Compteur = 0
    AnimeGus(OldNo)\ImageEnCours = AnimeGus(OldNo)\ImageDebut
    AnimeGus(OldNo)\TempsEnCours = ElapsedMilliseconds()
    OldNo = Gus\No
  EndIf  
  If ElapsedMilliseconds() - AnimeGus(Gus\No)\TempsEnCours > AnimeGus(Gus\No)\TempsMaxi
    AnimeGus(Gus\No)\ImageEnCours + 1
    AnimeGus(Gus\No)\TempsEnCours = ElapsedMilliseconds()

    If AnimeGus(Gus\No)\ImageEnCours > AnimeGus(Gus\No)\ImageFin 
      ; On boucle ?
      If AnimeGus(Gus\No)\Repetition = 0
        AnimeGus(Gus\No)\ImageEnCours = AnimeGus(Gus\No)\ImageBoucle 
      Else
        ; Compte le nombre de répétition
        AnimeGus(Gus\No)\Compteur + 1
        ; Si le nombre de répétition est atteint , on reste sur la dernière image
        If AnimeGus(Gus\No)\Compteur >=  AnimeGus(Gus\No)\Repetition
          AnimeGus(Gus\No)\ImageEnCours = AnimeGus(Gus\No)\ImageFin
        Else
          ;Sinon on reboucle 
          AnimeGus(Gus\No)\ImageEnCours = AnimeGus(Gus\No)\ImageBoucle
        EndIf  
      EndIf  
    EndIf  
  EndIf  
  ClipX = AnimeGus(Gus\No)\Taillex * AnimeGus(Gus\No)\ImageEnCours
  ClipSprite(AnimeGus(Gus\No)\Sprite, ClipX, 0, AnimeGus(Gus\No)\Taillex, AnimeGus(Gus\No)\TailleY)
  DisplayTransparentSprite(AnimeGus(Gus\No)\Sprite, Gus\X - AnimeGus(Gus\No)\PChaudX, Gus\Y - AnimeGus(Gus\No)\PChaudY) 
EndProcedure 
Procedure AffAide()
  No = Gus\Animation + Gus\Sens + Gus\Direction
  StartDrawing(ScreenOutput())
  DrawingMode(1)
  Locate(0,10)
DrawText(Str(AnimeGus(No)\ImageEnCours))
  StopDrawing()
EndProcedure  
;}
;{- Boucle Principale
Delay(1000)
Niveau()
Repeat

  ;While ( ElapsedMilliseconds()-LoopTimer )<#FPS : Wend 
  ;LoopTimer = ElapsedMilliseconds()
  ClearScreen(200,200,70)
  ;/ Montre les Palmiers
  ;If ShowMarqueurs
    AffPalmiers()
  ;EndIf  
  
  AfficheNiveau()

  GestionClavier()
;{- Gus Normal   
  If Gus\Etat = #E_Normal
    ;/ Chute en permanence
    If Gus\FlagA < 8
      Gus\FlagA + 1
    EndIf
    If Gus\FlagA < 99
      Gus\Y + Gus\FlagA 
    EndIf
    
    ;/ Replace les marqueurs 
    PositionMarqueurs()
    
    ;/ Mise à jour des collisions marqueurs
    Collision()
    
    ;/ La tête est touchée 
    If Marqueur(#M_Sol)\Collision And Gus\FlagA < 0
      Gus\Y - Gus\FlagA  + 1
      Gus\FlagA = 1
      Marqueur(#M_Sol)\Collision = 0
      PositionMarqueurs()
      Collision()
    EndIf
    
    ;/ Sol détecté , arrêt de la chute 
    If Marqueur(#M_Sol)\Collision And Gus\FlagA < 99
      Gus\FlagA = 99
      Gus\FlagSolA = 1
    EndIf
    ;/ Sol détecté replace le gus 
    If Gus\FlagSolA = 1
      ; Gus\y = Marqueur(#M_Sol)\Collision + 7
      For i = #M_Sol7 To #M_Sol1 Step - 1
        If Marqueur(i)\Collision = 0
          Gus\Y = Marqueur(i)\Y + Marqueur(i)\PChaudY + i
          Break
        EndIf 
      Next i
      Gus\FlagSolA = 0
    EndIf  
    ;/ Gestion chute
    If Marqueur(#M_Sol)\Collision 
      Gus\FlagB = 0
    Else
      Gus\FlagB = 1
    EndIf
    If Gus\FlagB  And Gus\FlagA = 99
      Gus\Animation = #SpTombe
      Gus\FlagA = 0
    EndIf  
    If Gus\Animation = #SpSaute  And Gus\FlagA > 0
      Gus\Animation = #SpTombe
    EndIf      
 
    
    ;/ Test déséquilibre 
    If Gus\FlagA = 99 
      Cond1 = Gus\Sens = #Droit And Marqueur(#M_BalanceG)\Collision And Marqueur(#M_BalanceD)\Collision = 0 And Marqueur(#M_PenteD)\Collision = 0
      Cond2 = Gus\Sens = #Gauche And Marqueur(#M_BalanceD)\Collision And Marqueur(#M_BalanceG)\Collision = 0 And Marqueur(#M_PenteG)\Collision = 0
      If Cond1 Or Cond2 
        Gus\Animation = #SpBalance
      EndIf 
    EndIf
    If Marqueur(#M_VideG)\Collision And Marqueur(#M_videD)\Collision = 0  
      Gus\X + 1
    EndIf  
    If Marqueur(#M_videD)\Collision And Marqueur(#M_VideG)\Collision = 0  
      Gus\X - 1
    EndIf 
    ;/Gestion de la pente
    ; Teste la direction ( ou pente )
    If Gus\Sens = #Gauche
      If Marqueur(#M_PenteG)\Collision = 0 And Marqueur(#M_PenteD)\Collision = 0
        Gus\Direction = 0
      ElseIf Marqueur(#M_PenteG)\Collision And Marqueur(#M_PenteD)\Collision = 0
        Gus\Direction = #Haut
        Gus\PasX = 10
      ElseIf Marqueur(#M_PenteG)\Collision And Marqueur(#M_PenteD)\Collision 
        Gus\Direction = #Haut  
        Gus\PasX = 20
        Gus\Y - 1
      EndIf
      If Marqueur(#M_HauteurG)\Collision = 0 And Marqueur(#M_HauteurD)\Collision 
        Gus\Direction = #Bas    
      EndIf   
    EndIf
    If Gus\Sens = #Droit  
      If Marqueur(#M_PenteG)\Collision = 0 And Marqueur(#M_PenteD)\Collision = 0
        Gus\Direction = 0
      ElseIf Marqueur(#M_PenteG)\Collision = 0 And Marqueur(#M_PenteD)\Collision 
        Gus\Direction = #Haut
        Gus\PasX = 30
      ElseIf Marqueur(#M_PenteG)\Collision And Marqueur(#M_PenteD)\Collision 
        Gus\Direction = #Haut
        Gus\PasX = 40
        Gus\Y - 1
      EndIf
      If Marqueur(#M_HauteurG)\Collision And Marqueur(#M_HauteurD)\Collision = 0
        Gus\Direction = #Bas    
      EndIf  
    EndIf
  
    If Marqueur(#M_Sol)\Collision And (Marqueur(#M_HauteurG)\Collision = 0 Or Marqueur(#M_HauteurD)\Collision = 0) 
      Gus\Y + 1
    EndIf    
    
    ;/ Le gus tombe
    If Gus\Animation =#SpTombe And Gus\FlagA = 99
      Gus\Animation = #SpBaisse
    EndIf 
    
    ;/Test si le Gus s'accroche à un rebord
    If Gus\Sens = #Gauche And Gus\FlagA > 0 And Gus\FlagA < 99
      Marqueur(#M_main)\X - 10
      Marqueur(#M_main)\Y - 30
      CollisionMain()
    EndIf
    If Gus\Sens = #Droit And Gus\FlagA > 0 And Gus\FlagA < 99
      Marqueur(#M_main)\X + 10
      Marqueur(#M_main)\Y - 30
      CollisionMain()
    EndIf  
    If Gus\Sens = #Gauche And Gus\FlagA > 0 And Gus\FlagA < 99 And Marqueur(#M_main)\Collision  
      Gus\Etat = #E_Agrippe
      Gus\FlagA = 99
      Gus\Animation = #SpAgrippe
      Gus\X = MEmMainX + Marqueur(#M_Rebord)\PChaudX + 9
      Gus\Y = MEmMainY + Marqueur(#M_Rebord)\PChaudY + 20
    EndIf
    If Gus\Sens = #Droit And Gus\FlagA > 0 And Gus\FlagA < 99 And Marqueur(#M_main)\Collision 
      Gus\Etat = #E_Agrippe
      Gus\FlagA = 99
      Gus\Animation = #SpAgrippe
      Gus\X = MEmMainX + Marqueur(#M_Rebord)\PChaudX - 9
      Gus\Y = MEmMainY + Marqueur(#M_Rebord)\PChaudY + 20
    EndIf 
  EndIf
  
;}  
  
  ;/animation du Gus
  Animation()


  ;AffAide()
  FlipBuffers()
  If IsScreenActive()=0
    Repeat
      Delay(20)
      FlipBuffers()
    Until IsScreenActive()
  EndIf
Until KeyboardPushed(#PB_Key_Escape)  
;}
;{- Les datas
DataSection
Niveau1: 
Data.l 000, 000, 000, 000, 000, 000, 171, 178, 185, 074, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000
Data.l 185, 074, 000, 000, 000, 000, 167, 166, 077, 042, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000
Data.l 039, 042, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000
Data.l 032, 000, 000, 000, 171, 198, 177, 185, 177, 178, 870, 871, 000, 000, 000, 000, 000, 000, 000, 000
Data.l 176, 000, 000, 000, 060, 183, 179, 180, 181, 180, 872, 873, 870, 871, 000, 000, 000, 000, 000, 000
Data.l 076, 016, 015, 013, 045, 180, 182, 179, 180, 179, 181, 180, 872, 873, 186, 198, 185, 177, 178, 177
Data.l 182, 181, 183, 180, 179, 181, 180, 179, 182, 180, 179, 182, 183, 179, 182, 179, 181, 182, 183, 179
Marqueurs:
Data.s "M_Sol"
Data.l 3, -1, 0, 0
Data.s "M_Sol1"
Data.l 3, -1, 0, 0
Data.s "M_Sol2"
Data.l 3, -1, 0, 0
Data.s "M_Sol3"
Data.l 3, -1, 0, 0
Data.s "M_Sol4"
Data.l 3, -1, 0, 0
Data.s "M_Sol5"
Data.l 3, -1, 0, 0
Data.s "M_Sol6"
Data.l 3, -1, 0, 0
Data.s "M_Sol7"
Data.l 3, -1, 0, 0
Data.s "M_BarriereG"
Data.l 14, 31, 4, 0
Data.s "M_BarriereD"
Data.l -10, 31, 0, 0
Data.s "M_PenteG"
Data.l 6, 1, 3, 0
Data.s "M_PenteD"
Data.l -4, 1, 0, 0
Data.s "M_HauteurG"
Data.l 7, -1, 0, 0
Data.s "M_HauteurD"
Data.l 0, -1, 8, 0
Data.s "M_VideG"
Data.l 4, -2, -6, -13
Data.s "M_videD"
Data.l -3, -2, 8, -13
Data.s "M_BalanceG"
Data.l 9, -2, -6, -13
Data.s "M_BalanceD"
Data.l -8, -2, 8, -13
Data.s "M_main"
Data.l 2, 3, -15, -8
Data.s "M_Rebord"
Data.l 5, 3, -4, -9

; Les datas doivent être rangées dans le même ordre que les constantes 
Animations:
;{- Direction = 0
Data.s "Arret Gauche"
Data.l 0, 0, 0, 0, 1, 0, 66, 35, 0, 60
Data.l 33, 34 , 11, 14
Data.s "Balance Gauche"
Data.l 0, 0, 14, 0, 0, 0, 66, 35, 0, 60
Data.l 41, 34 , 33, 17
Data.s "Marche Gauche"
Data.l 0, 0, 9, 0, 0, 0, 66, 35, 0, 60
Data.l 33, 34 , 33, 17
Data.s "Saute Gauche"
Data.l 0, 0, 0, 0, 1, 0, 66, 35, 0, 60
Data.l 33, 34 , 33, 17
Data.s "Tombe Gauche"
Data.l 0, 0, 1, 0, 0, 0, 66, 47, 0, 60
Data.l 33, 46 , 33, 23
Data.s "tir balle Gauche"
Data.l 0, 0, 2, 0, 0, 0, 66, 35, 0, 60
Data.l 33, 34 , 11, 14
Data.s "agrippe gauche"
Data.l 0, 0, 10, 4, 0, 0, 66, 70, 0, 60
Data.l 33, 35 , 11, 14
Data.s "Rebondit gauche"
Data.l 0, 0, 1, 0, 1, 0, 66, 61, 0, 60
Data.l 33, 60 , 11, 14
Data.s "Baisse gauche"
Data.l 0, 0, 4, 0, 1, 0, 66, 61, 0, 20
Data.l 33, 60 , 11, 14

Data.s "Arret Droit"
Data.l 0, 0, 0, 0, 1, 0, 66, 35, 0, 60 
Data.l 33, 34 , 55, 14
Data.s "Balance Droit"
Data.l 0, 0, 14, 0, 0, 0, 66, 35, 0, 60
Data.l 25, 34 , 33, 17
Data.s "Marche droit"
Data.l 0, 0, 9, 0, 0, 0, 66, 35, 0, 60
Data.l 33, 34 , 33, 17
Data.s "Saute Droit"
Data.l 0, 0, 0, 0, 1, 0, 66, 35, 0, 60
Data.l 33, 34 , 33, 17
Data.s "Tombe Droit"
Data.l 0, 0, 1, 0, 0, 0, 66, 47, 0, 60
Data.l 33, 46 , 33, 23
Data.s "tir balle droit"
Data.l 0, 0, 2, 0, 0, 0, 66, 35, 0, 60
Data.l 33, 34 , 55, 14
Data.s "agrippe droit"
Data.l 0, 0, 10, 4, 0, 0, 66, 70, 0, 60
Data.l 33, 35 , 11, 14
Data.s "Rebondit droit"
Data.l 0, 0, 1, 0, 1, 0, 66, 61, 0, 60
Data.l 33, 60 , 11, 14
Data.s "Baisse droit"
Data.l 0, 0, 4, 0, 1, 0, 66, 61, 0, 20
Data.l 33, 60 , 11, 14
;}
;{- Direction = #Haut
Data.s "Arret haut Gauche"
Data.l 0, 0, 0, 0, 1, 0, 66, 38, 0, 60
Data.l 33, 34 , 13, 13
Data.s "Balance Gauche"
Data.l 0, 0, 14, 0, 0, 0, 66, 35, 0, 60
Data.l 41, 34 , 33, 17
Data.s "Marche haut Gauche"
Data.l 0, 0, 9, 0, 0, 0, 66, 38, 0, 60
Data.l 33, 34 , 33, 19
Data.s "Saute Gauche"
Data.l 0, 0, 0, 0, 1, 0, 66, 35, 0, 60
Data.l 33, 34 , 33, 17
Data.s "Tombe Gauche"
Data.l 0, 0, 1, 0, 0, 0, 66, 47, 0, 60
Data.l 33, 46 , 33, 23
Data.s "tir balle Gauche"
Data.l 0, 0, 2, 0, 0, 0, 66, 35, 0, 60
Data.l 33, 34 , 11, 14
Data.s "agrippe gauche"
Data.l 0, 0, 10, 4, 0, 0, 66, 70, 0, 60
Data.l 33, 35 , 11, 14
Data.s "Rebondit gauche"
Data.l 0, 0, 1, 0, 1, 0, 66, 61, 0, 60
Data.l 33, 60 , 11, 14
Data.s "Baisse haut gauche"
Data.l 0, 0, 4, 0, 1, 0, 66, 64, 0, 20
Data.l 33, 60 , 33, 32

Data.s "Arret haut Droit"
Data.l 0, 0, 0, 0, 1, 0, 66, 38, 0, 60 
Data.l 33, 34 , 52, 14
Data.s "Balance Droit"
Data.l 0, 0, 14, 0, 0, 0, 66, 35, 0, 60
Data.l 25, 34 , 33, 17
Data.s "Marche haut droit"
Data.l 0, 0, 9, 0, 0, 0, 66, 38, 0, 60
Data.l 33, 34 , 33, 19
Data.s "Saute Droit"
Data.l 0, 0, 0, 0, 1, 0, 66, 35, 0, 60
Data.l 33, 34 , 33, 17
Data.s "Tombe Droit"
Data.l 0, 0, 1, 0, 0, 0, 66, 47, 0, 60
Data.l 33, 46 , 33, 23
Data.s "tir balle droit"
Data.l 0, 0, 2, 0, 0, 0, 66, 35, 0, 60
Data.l 33, 34 , 55, 14
Data.s "agrippe droit"
Data.l 0, 0, 10, 4, 0, 0, 66, 70, 0, 60
Data.l 33, 35 , 11, 14
Data.s "Rebondit droit"
Data.l 0, 0, 1, 0, 1, 0, 66, 61, 0, 60
Data.l 33, 60 , 11, 14
Data.s "Baisse haut droit"
Data.l 0, 0, 4, 0, 1, 0, 66, 64, 0, 20
Data.l 33, 60 , 33, 32
;}

;{- Direction = #Bas
Data.s "Arret bas Gauche"
Data.l 0, 0, 0, 0, 1, 0, 66, 64, 0, 60
Data.l 29, 62 , 8, 40
Data.s "Balance Gauche"
Data.l 0, 0, 14, 0, 0, 0, 66, 35, 0, 60
Data.l 41, 34 , 33, 17
Data.s "Marche bas Gauche"
Data.l 0, 0, 9, 0, 0, 0, 66, 38, 0, 60
Data.l 29, 36 , 33, 19
Data.s "Saute Gauche"
Data.l 0, 0, 0, 0, 1, 0, 66, 35, 0, 60
Data.l 33, 34 , 33, 17
Data.s "Tombe Gauche"
Data.l 0, 0, 1, 0, 0, 0, 66, 47, 0, 60
Data.l 33, 46 , 33, 23
Data.s "tir balle Gauche"
Data.l 0, 0, 2, 0, 0, 0, 66, 35, 0, 60
Data.l 33, 34 , 11, 14
Data.s "agrippe gauche"
Data.l 0, 0, 10, 4, 0, 0, 66, 70, 0, 60
Data.l 33, 35 , 11, 14
Data.s "Rebondit gauche"
Data.l 0, 0, 1, 0, 1, 0, 66, 61, 0, 60
Data.l 33, 60 , 11, 14
Data.s "Baisse bas gauche"
Data.l 0, 0, 4, 0, 1, 0, 66, 64, 0, 20
Data.l 29, 62 , 33, 32

Data.s "Arret bas Droit"
Data.l 0, 0, 0, 0, 1, 0, 66, 64, 0, 60 
Data.l 37, 62 , 57, 40
Data.s "Balance Droit"
Data.l 0, 0, 14, 0, 0, 0, 66, 35, 0, 60
Data.l 25, 34 , 33, 17
Data.s "Marche bas droit"
Data.l 0, 0, 9, 0, 0, 0, 66, 38, 0, 60
Data.l 37, 36 , 33, 19
Data.s "Saute Droit"
Data.l 0, 0, 0, 0, 1, 0, 66, 35, 0, 60
Data.l 33, 34 , 33, 17
Data.s "Tombe Droit"
Data.l 0, 0, 1, 0, 0, 0, 66, 47, 0, 60
Data.l 33, 46 , 33, 23
Data.s "tir balle droit"
Data.l 0, 0, 2, 0, 0, 0, 66, 35, 0, 60
Data.l 33, 34 , 55, 14
Data.s "agrippe droit"
Data.l 0, 0, 10, 4, 0, 0, 66, 70, 0, 60
Data.l 33, 35 , 11, 14
Data.s "Rebondit droit"
Data.l 0, 0, 1, 0, 1, 0, 66, 61, 0, 60
Data.l 33, 60 , 11, 14
Data.s "Baisse bas droit"
Data.l 0, 0, 4, 0, 1, 0, 66, 64, 0, 20
Data.l 37, 62 , 33, 32
;}

Obstacles:

Data.s "13"
Data.s "15"
Data.s "16"
Data.s "32"
Data.s "39"
Data.s "42"
Data.s "45"
Data.s "60"
Data.s "74"
Data.s "76"
Data.s "77"
Data.s "87"
Data.s "166"
Data.s "167"
Data.s "171"
Data.s "176"
Data.s "177"
Data.s "178"
Data.s "179"
Data.s "180"
Data.s "181"
Data.s "182"
Data.s "183"
Data.s "185"
Data.s "186"
Data.s "198"
Data.s "870"
Data.s "871"
Data.s "872"
Data.s "873"


EndDataSection
;}

morukutsu · Message par **morukutsu** » dim. 21/août/2005 22:45

djes a écrit :Pfff! Ca me fait rire ces histoires de paraboles. Y'a pas besoin de maths pour ça!!!! Tu le fais avec des variables x,y et des vitesses qui décroivent.
Plus tard, quand tu seras un peu plus fort, tu feras une petite table contenant un sinus et ce sera parfait.

Edit : ortho

Si c'est si simple que ça,

tu pourrais pas pondre un petit code ? Car c'est peut etre pas évident pour tout le monde ? ( en tout cas pas pour moi ^^ )

poshu · Message par **poshu** » lun. 22/août/2005 11:34

bon, j'ai ressortie des cours de math et j'ai fait un test avec une parabole, ca marche tres bien.

morukutsu · Message par **morukutsu** » lun. 22/août/2005 11:45

T'aurais pas le code à me donner s'il te plait ? Ou seulement des explications car avec mon niveau Maths 4ème ...

djes · Message par **djes** » lun. 22/août/2005 16:33

morukutsu a écrit :
djes a écrit :Pfff! Ca me fait rire ces histoires de paraboles. Y'a pas besoin de maths pour ça!!!! Tu le fais avec des variables x,y et des vitesses qui décroivent.
Plus tard, quand tu seras un peu plus fort, tu feras une petite table contenant un sinus et ce sera parfait.

Edit : ortho
Si c'est si simple que ça, tu pourrais pas pondre un petit code ? Car c'est peut etre pas évident pour tout le monde ? ( en tout cas pas pour moi ^^ )

Il est très rare que je donne du code. Où serait le plaisir de programmer, et de chercher? Mais bon, disons simplement que tu as ton perso positionné grâce aux variables x et y (tu suis là ?

)
Tu le fais avancer en x grâce x=x+1 d'accord? Reculer grâce à x=x-1
Tu veux le faire sauter, tu fais une variable saut qui vaut par exemple 5 et tu fais y=y-saut. Il ne te reste plus qu'à décrémenter (réduire de 1) la variable saut, et ... que va-t-il se passer si tu fais ça plusieurs fois (dans une boucle) ?

Ca fait une parabole! Le reste, je te laisse trouver.