PureBasic

@comtois : tout a fait d'accord avec toi

si ça marche je mettrais mon code ici ..

Pour limiter la vitesse du tout en obtenant la même vitesse sur tout les PC, j'avais fait ça sur mon jeu "Stratégie" (faut fouiller la rubrique jeux)

Code : Tout sélectionner

    #Rapidite_Regulation = 3
    Cpt_Temps + 1
    If Cpt_Temps = #Rapidite_Regulation
      fps = Int(#Rapidite_Regulation * 1000 / (GetTickCount_() - Temps))
      Temps = GetTickCount_()
      Cpt_Temps = 0
      If fps < 30 And VitesseJeu > 0
        VitesseJeu - 1
      ElseIf fps > 35
        VitesseJeu + 1
      EndIf
    EndIf
    Delay(VitesseJeu)

J'explique :
mon truc est basé sur le FPS, j'ai choisie un FPS situé entre 30 et 35 qui permet de tourner sur beaucoup de PC et qui permet de ne pas avoir d'à-coup visuel. ça permet également de garder une vitesse constantes quelque soit les application en arrière plan.

d'abord, je calcule le FPS à l'aide d'un GetTickCount_() ou ElapsedMillisecond()
(Nombre d'image) / (nb seconde écoulé)

ensuite, j'ai placé un delay variable.
ce delay va varier comme suit :
- si fps trop élevé, on augmente, le delay
- si fps trop bas, on diminue le delay

j'espère que ça va aider

moi je me serai pas cassé la tete , j'aurai utilisé un soft de capture d'image animée (ça doit existé ) et je m'aurai enregistré une video courte(pour la taille compressé en divx) pendant que je joue , puis j'aurai fait rejouer l'anime en boucle ! c'est une methode qui prend de la place alors , c'est pas ideal, mais c'est simple a faire en theorie

@soldat inconnu: pas bête du tout je vais surment rajouter cette fonction
@Dobro: oui j'avais pensé a ça...c'est une solution ! :p

Dobro a écrit :moi je me serai pas cassé la tete , j'aurai utilisé un soft de capture d'image animée (ça doit existé )

Il en existe un, CamStudio 2.0, il prend 5 images/seconde pour une résolution 1024*768, je ne sais pas ce que ça peut donner mais c'est un Freeware et il à été traduit en Français.

http://www.framasoft.net/article1045.html

Il y a aussi 'Fraps' qui marche bien

http://www.fraps.com

Super Merci a Nico et Cookie ! Je ne connaissais pas et j'en cherchais un !! :p

ça doit mem pouvoir se faire en pure !

il suffirait de sauvegarder les images ecran en les numerotant , puis avec un soft les rassembler pour en faire une anime (un gif animer ?)< 256 couleurs je crois !

Je dis peut-être une anerie, vu que j'ai pas tout suivi, mais il y a peut-être aussi la solution d'enregistrer la position X et la position Y de ton perso, et l'état des différentes variables qui constituent les actions, (tirer, courir, sauter, ramasser quelque chose, etc...)

Beaucoup de démos de jeux fonctionnent selon ce principe, ce qui permet d'avoir des fichiers avec un poids beaucoup plus réduit que si tu enregistre entièrement des images.

Il suffit d'initialiser ton fichier au départ, avec le n° tu tableau, la position de départ, le fps, la durée de la démo, et en principe, ça doit rouler.

Enfin, moi, ce que j'en dit

@Chris: non, non tu ne dis pas de bêtises c'est d'ailleur ce que je vais faire dans ma prochaine tentative
@Dobro:c'est vrai que c'est une solution d'enregistré les images mais bon trop volumineux....

Voilà ce que donne mes derniers essaies, mais bon je previens ce n'est pas encore "la solution" vu que ça marche qu'en théorie ! Car en pratique le personnage se deplace bien mais sans aucune précision

j'ai une varible appelé 'DEMO'
si DEMO=0 on joue normalement
si DEMO=1 on enregistre la partie
si DEMO=2 on joue la partie enregistré

J'ai initialisé des structures pour chaques touches

Code : Tout sélectionner

Structure demo
  valeur.l
  wait.l
EndStructure
NewList key_up.demo()
NewList key_Down.demo()
NewList key_Right.demo()
NewList key_Left.demo()
NewList key_Action.demo()
NewList key_Saut.demo()

Avant d'aller plus loin je met les variables des touches dans une variable ça me permettra par la suite de redefinir si je veux les touches facilement

Code : Tout sélectionner

  Key_Up = #PB_Key_Up
  Key_Down = #PB_Key_Down
  Key_Right = #PB_Key_Right
  Key_Left = #PB_Key_Left
  Key_Saut = #PB_Key_space
  Key_Action = #PB_Key_LeftControl

Avant la boucle principal du jeu on trouve:

Code : Tout sélectionner

;-Init demo
  Demo=0; 1 pour enregistrer la partie et 2 pour la rejouer
  Wait_KeyRight = ElapsedMilliseconds()
  Wait_KeyLeft = Wait_KeyRight
  Wait_KeyUp=Wait_KeyRight
  Wait_KeyDown=Wait_KeyRight
  Wait_KeyAction= Wait_KeyRight
  Wait_KeySaut=Wait_KeyRight
    If Demo=2
  OpenFile(0, "demo.tmp")
    nb=ReadLong()
    For z=0 To nb
    AddElement(Key_Right())
      Key_Right()\valeur=ReadLong()
      Key_Right()\wait=ReadLong()
    Next
    nb=ReadLong()
    For z=0 To nb
    AddElement(Key_Left())
      Key_Left()\valeur=ReadLong()
      Key_Left()\wait=ReadLong()
    Next
    nb=ReadLong()
    For z=0 To nb
    AddElement(Key_Up())
      Key_Up()\valeur=ReadLong()
      Key_Up()\wait=ReadLong()
    Next
    nb=ReadLong()
    For z=0 To nb
    AddElement(Key_Down())
      Key_Down()\valeur=ReadLong()
      Key_Down()\wait=ReadLong()
    Next
    nb=ReadLong()
    For z=0 To nb
    AddElement(Key_Action())
      Key_Action()\valeur=ReadLong()
      Key_Action()\wait=ReadLong()
    Next
    nb=ReadLong()
    For z=0 To nb
    AddElement(Key_Saut())
      Key_Saut()\valeur=ReadLong()
      Key_Saut()\wait=ReadLong()
    Next
 CloseFile(0)
 ResetList(Key_Right())
 ResetList(Key_Left())
 ResetList(Key_Up())
 ResetList(Key_Down())
 ResetList(Key_Action())
 ResetList(Key_Saut())
  EndIf

Donc selon le mode on charge ou pas le fichier
Ensuite dans la boucle principal on trouve :

Code : Tout sélectionner

 ;- Gestion Demo
    Select Demo
    Case 0 ; on joue normalement
     Demo_KeyRight = KeyboardPushed(Key_Right)
     Demo_KeyLeft = KeyboardPushed(Key_Left)
     Demo_KeyUp= KeyboardPushed(Key_Up)
     Demo_KeyDown= KeyboardPushed(Key_Down)
     Demo_KeyAction= KeyboardPushed(Key_Action)
     Demo_KeySaut= KeyboardPushed(Key_Saut)
    Case 1 ; On enregistre les mouvements
      If Demo_KeyRight<>  KeyboardPushed(Key_Right)
        AddElement(Key_Right())
        Key_Right()\valeur = Demo_KeyRight
        Key_Right()\wait = ElapsedMilliseconds() - Wait_KeyRight
        Wait_KeyRight = ElapsedMilliseconds()
        Demo_KeyRight = KeyboardPushed(Key_Right)

      EndIf
      
      If Demo_KeyLeft <> KeyboardPushed(Key_Left)
        AddElement(Key_Left())
        Key_Left()\valeur = Demo_KeyLeft
        Key_Left()\wait = ElapsedMilliseconds() - Wait_KeyLeft
        Wait_KeyLeft = ElapsedMilliseconds()
        Demo_KeyLeft = KeyboardPushed(Key_Left)
      EndIf
      
      If Demo_KeyUp <> KeyboardPushed(Key_Up)
        AddElement(Key_Up())
        Key_Up()\valeur = Demo_KeyUp
        Key_Up()\wait = ElapsedMilliseconds() - Wait_KeyUp
        Wait_KeyUp = ElapsedMilliseconds()
        Demo_KeyUp = KeyboardPushed(Key_Up)
      EndIf
      
      If Demo_KeyDown <> KeyboardPushed(Key_Down)
        AddElement(Key_Down())
        Key_Down()\valeur = Demo_KeyDown
        Key_Down()\wait = ElapsedMilliseconds() - Wait_KeyDown
        Wait_KeyDown = ElapsedMilliseconds()
        Demo_KeyDown = KeyboardPushed(Key_Down)
      EndIf
      
      If Demo_KeySaut <> KeyboardPushed(Key_Saut)
        AddElement(Key_Saut())
        Key_Saut()\valeur = Demo_KeySaut
        Key_Saut()\wait = ElapsedMilliseconds() - Wait_KeySaut
        Wait_KeySaut = ElapsedMilliseconds()
        Demo_KeySaut = KeyboardPushed(Key_Saut)
      EndIf
      
      If Demo_KeyAction <> KeyboardPushed(Key_Action)
        AddElement(Key_Action())
        Key_Action()\valeur = Demo_KeyAction
        Key_Action()\wait = ElapsedMilliseconds() - Wait_KeyAction
        Wait_KeyAction = ElapsedMilliseconds()
        Demo_KeyAction = KeyboardPushed(Key_Action)
      EndIf
      
    Case 2 ; on joue automatiquement une partie
      If ElapsedMilliseconds()>= Wait_KeyRight
       NextElement(Key_Right())
       Wait_KeyRight=ElapsedMilliseconds()+Key_Right()\wait
       Demo_KeyRight =Key_Right()\valeur
      EndIf
      If ElapsedMilliseconds()>= Wait_KeyLeft
       NextElement(Key_Left())
       Wait_KeyLeft=ElapsedMilliseconds()+Key_Left()\wait
       Demo_KeyLeft =Key_Left()\valeur
      EndIf
            If ElapsedMilliseconds()>= Wait_KeyUp
       NextElement(Key_Up())
       Wait_KeyUp=ElapsedMilliseconds()+Key_Up()\wait
       Demo_KeyUp =Key_Up()\valeur
      EndIf
            If ElapsedMilliseconds()>= Wait_KeyDown
       NextElement(Key_Down())
       Wait_KeyDown=ElapsedMilliseconds()+Key_Down()\wait
       Demo_KeyDown =Key_Down()\valeur
      EndIf
            If ElapsedMilliseconds()>= Wait_KeyAction
       NextElement(Key_Action())
       Wait_KeyAction=ElapsedMilliseconds()+Key_Action()\wait
       Demo_KeyAction =Key_Action()\valeur
      EndIf
            If ElapsedMilliseconds()>= Wait_KeySaut
       NextElement(Key_Saut())
       Wait_KeySaut=ElapsedMilliseconds()+Key_Saut()\wait
       Demo_KeySaut =Key_Saut()\valeur
      EndIf
    EndSelect

Pour gerer le personnage j'utilise donc cela, toujours dans la boucle

if Demo_KeyUp>0 : je monte
...
Endif
if Demo_KeyDown>0 : je descend
...
Endif
if Demo_KeyRight>0 : je vais a droite
...
Endif
if Demo_KeyLeft>0 : je vais a gauche
...
Endif
if Demo_KeySaut>0 : je saute
...
Endif
if Demo_KeyAction>0 : je fais une action
...
Endif

ensuite une fois la partie terminé. Donc juste apres la boucle principal On sauvegarde la partie avec ce code

Code : Tout sélectionner

  If Demo=1
   ResetList(Key_Right())
 ResetList(Key_Left())
 ResetList(Key_Up())
 ResetList(Key_Down())
 ResetList(Key_Action())
 ResetList(Key_Saut())
  CreateFile(0, "demo.tmp")
    WriteLong(CountList(Key_Right()))
    While NextElement(Key_Right())
      WriteLong(Key_Right()\valeur)
      WriteLong(Key_Right()\wait)
    Wend 
    WriteLong(CountList(Key_Left()))
    While NextElement(Key_Left())
      WriteLong(Key_Left()\valeur)
      WriteLong(Key_Left()\wait)
    Wend  
    WriteLong(CountList(Key_Up()))
    While NextElement(Key_Up())
      WriteLong(Key_Up()\valeur)
      WriteLong(Key_Up()\wait)
    Wend    
    WriteLong(CountList(Key_Down()))
    While NextElement(Key_Down())
      WriteLong(Key_Down()\valeur)
      WriteLong(Key_Down()\wait)
    Wend
        WriteLong(CountList(Key_Action()))
    While NextElement(Key_Action())
      WriteLong(Key_Action()\valeur)
      WriteLong(Key_Action()\wait)
    Wend
        WriteLong(CountList(Key_Saut()))
    While NextElement(Key_Saut())
      WriteLong(Key_Saut()\valeur)
      WriteLong(Key_Saut()\wait)
    Wend  
  CloseFile(0)

Donc ça fonctione.. enfin plus ou moins car c'est pas précis du tout ! J'ai l'impression qu'il ya un problème de synchro entre toute les touches
Resultat c'est pas precis du tout et mon personage vas souvant trop loin par rapport a la position ou il devrait être Bref c'est pas encore ça...
Donc si certain voie une erreur ou trouve une idée pour être sur que ça fonctionne synchro qu'il n'hesite pas

PureBasic

Partie Demonstration d'un Jeu