Forum de Ti-Gen.org, le site francophone des TI

Bienvenue Invité ! Se connecter Mes sujets	Administrer
Utilisateurs actifs : Aucun membre + 1 visiteur

Avant de poster sur le forum, il y a des régles de bases à respecter pour une bonne entente et un respect de tous.
Veuillez lire la charte du forum.

:: Index » Forum Ti68K » Programmation C » Régulation de vitesse d'un jeu (7 réponse(s))

./POST DE DEPART (post n°0) Marquer comme non lu.

Xantares

Ecrit le: Dimanche 9 juillet 2006 à 16:10

Membre: Habitué

Messages: 63

Membre n°875

Inscrit le 09 juin 2005

Bonjour

Je suis en train d'essayer de coder un jeu, je me heurte à ce problème :
J'ai plusieurs objets qui se deplacent à l'écran, mais ceux ci sont en nombre variable au cours du jeu, leur nombre variant, donc le temps de traitement de la boucle modification/affichage varie aussi du coup les objets vont plus ou moins vite selon la complexité de la scène.

j'ai préparé ce petit exemple pour illustrer :

#define USE_TI89
#define MIN_AMS 100
#define SAVE_SCREEN

#include <tigcclib.h>

static unsigned char balle[]={
0b00011000,
0b01111110,
0b01111110,
0b11111111,
0b11111111,
0b01111110,
0b01111110,
0b00011000};

void affballe(float x, float y)
{
  Sprite8(floor(x),floor(y),8,balle,LCD_MEM, SPRT_XOR);
}

void _main(void)
{
  const int nballes=5;
  floatx[]={56,41,150,119,67},y[]={2,14,87,66,32},
        vx[]={0.5,0.5,0.5,0.5,0.5},vy[]={0.5,0.5,0.5,0.5,0.5};
  clrscr();
  int i;
  for(i=0;i<nballes;i++)
    affballe(x[i],y[i]);
  for(;
  {
    if (_keytest (RR_ESC)) exit(0);
    for(i=0;i<nballes;i++)
    {
      affballe(x[i],y[i]);
      x[i]+=vx[i];
      if(x[i]>152 || x[i]<0) vx[i]=-vx[i];
      y[i]+=vy[i];
      if(y[i]>90 || y[i]<0) vy[i]=-vy[i];
      affballe(x[i],y[i]);
    }
  }
}

Lorsque l'on change le nobre de balles dans la scène (variable nballes) on voie que la vitesse de l'animation change grossièrement.

Je me suis donc regardé sur l'article de LionelA.
J'ai pas tout compris.

Déja quand est-ce que le code suivant s'execute-t-il ?

DEFINE_INT_HANDLER (SceneModif)

  ExecuteHandler (OldInt1);
  //HARDWARE VERSION 1.0
  if (hwVersion==1)
  {
    //Incrémentation
    counter_hardware+=HARDWARE_FREQUENCY;

    //Execution interrupotion
    if (counter_hardware<=32768 )
      return;
    //Remise à zéro
    counter_hardware-=32768;
  }

Ensuite la partie suivante est obscure mais elle parait cruciale :

if (!modifying && !nextModif)
  {
    modifying = 1;
    nextModif = GAME_SPEED;
    display_Modif();
    modifying = 0;
  }
  if(nextModif)
    nextModif--;

je pense que ca devrait definir quand aura lieu la prochaine modification de la scene à partir de GAME_SPEED
Mais il y a un truc pas clair : alors le code qui sera executé apres sera la partie de rendu de la scene ? si c'est le cas je vois pas l'interet d'effectuer un rendu si la scene est pas encore modifiée.
C'est un peu flou pour moi. #compris#

Troisièmo, comment GAME_SPEED fonctionne ? lors de son utilisation elle decroit jusqu'à 0 dans une boucle, mais qu'est ce qui fait que la boucle est maintenue à une certaine vitesse ?
c l'interrupt 1 ? mais déjà concretement l'interrupt 1 c quoi un flag qui fait 0-1 à ~350khz (enfin la frequence là quoi) ? et la commande ExecuteHandler (OldInt1); elle fait quoi precisement ?

Bon là c'est sûr je dépasse le quota de questions autorisées. :]

Ce serait bien si qqn pouvait me montrer un exemple de comment on utilise tout ca, ou comment l'implementer dans l'exemple au-dessus, mais surtout j'aimerais comprendre comment ca marche ce machin

./Post n°1 Marquer comme non lu.

Jfg

Ecrit le: Dimanche 9 juillet 2006 à 17:56

Administrateur

Groupe: Staff de Ti-Gen

Groupe: Orage Studio

Messages: 1260

Membre n°60

Inscrit le 23 février 2004

Dans son article, LionelA décrit comment réguler la vitesse d'un jeu de manière à exploiter 100% les ressources de la calculette, c'est à dire sans boucle d'attente. Cette méthode est super bien, mais largement plus compliqué que l'autre méthode. Je te conseil donc de ne pas te baser sur cette article pour le moment (désolé LionelA

)

Pour réguler la vitesse de ton jeu de manière simple, tu peux insérer dans ton code une boucle d'attente. La boucle d'attente va attendre un signal disant qu'il faut arrêter d'attendre. Ce signal sera déclanché par un timer.

Essaye de regarder la documentation incluse dans TIGCC, en particulié "DEFINE_INT_HANDLER" (il y a un exemple qui devrait t'aider).

Kill Mario

./Post n°2 Marquer comme non lu.

Xantares

Ecrit le: Dimanche 9 juillet 2006 à 20:06

Membre: Habitué

Messages: 63

Membre n°875

Inscrit le 09 juin 2005

mouais vais regarder

merci
-Edité le Dimanche 9 juillet 2006 à 20:07 par Xantares-

./Post n°3 Marquer comme non lu.

Kevin Kofler

Ecrit le: Lundi 10 juillet 2006 à 04:14

Administrateur

Groupe: Staff de Ti-Gen

Messages: 4814

Membre n°40

Inscrit le 08 février 2004

La méthode de LionelA est tout sauf "bien" en plus, c'est un hack sale et grossier.

Membre de l'équipe de TIGCC: http://tigcc.ticalc.org
Mainteneur du portage Linux/Unix de TIGCC: http://tigcc.ticalc.org/linux/
Membre de l'équipe de CalcForge: http://www.calcforge.org:70/

Participez à la reprise de Ti-Gen!

./Post n°4 Marquer comme non lu.

Xantares

Ecrit le: Lundi 10 juillet 2006 à 09:12

Membre: Habitué

Messages: 63

Membre n°875

Inscrit le 09 juin 2005

d'après ses dires ca fonctionne : je pense pas que son f-zero soit à renier

quelle méthode (propre ?) proposes-tu alors ?
-Edité le Lundi 10 juillet 2006 à 09:17 par Xantares-

./Post n°5 Marquer comme non lu.

Xantares

Ecrit le: Lundi 10 juillet 2006 à 11:17

Membre: Habitué

Messages: 63

Membre n°875

Inscrit le 09 juin 2005

j'ai pondu un truc là : j'ai repris mon exemple des balles.

j'ai fait en sorte que la position est incrementée en fonction du temps d'éxecution de la fonction d'affichage qui a été éxecutée à la boucle précedente

x+=dt*v avec dt temps de la procedure d'affichage

ce temps est exprimé en fonction d'un timer incrementé sur l'auto_int 1

quelle est la fréquence précise de l'aut_int 1 ?
j'ai eu raison de le mettre sur l'int 1 plutot que sur le 5 ?
j'ai eu l'imprssion que le 1 est plus rapide est-ce vrai ?

#define USE_TI89
#define MIN_AMS 100
#define SAVE_SCREEN

#include <tigcclib.h>

INT_HANDLER OldInt1 = NULL;
volatile int temps = 0;

DEFINE_INT_HANDLER(MyInt1)
{
  temps++;
  ExecuteHandler (OldInt1);
}

static unsigned char balle[]={
0b00011000,
0b01111110,
0b01111110,
0b11111111,
0b11111111,
0b01111110,
0b01111110,
0b00011000};

void affballe(float x, float y)
{
  Sprite8(floor(x),floor(y),8,balle,LCD_MEM, SPRT_XOR);
}

void _main(void)
{
  OldInt1 = GetIntVec (AUTO_INT_1);
  SetIntVec (AUTO_INT_1, MyInt1);
  const int nballes=1;
  float x[]={56,41,150,119,67},y[]={2,14,87,66,32},vx[]={0.5,0.5,0.5,0.5,0.5},vy[]={0.5,0.5,0.5,0.5,0.5};
  clrscr();
  int j,dt=2;
  for(j=0;j<nballes;j++)
    affballe(x[j],y[j]);
  for(;
  {
    if (_keytest (RR_ESC)) break;
    temps=0;
    for(j=0;j<nballes;j++)
    {
      affballe(x[j],y[j]);
      x[j]+=dt*vx[j];
      if(x[j]>152 || x[j]<0) vx[j]=-vx[j];
      y[j]+=dt*vy[j];
      if(y[j]>90 || y[j]<0) vy[j]=-vy[j];
      affballe(x[j],y[j]);
    }
    printf_xy (50, 50, "Counter = %d  ", temps);
    dt=temps/5;
    if(dt==0) dt++;
  }
  SetIntVec (AUTO_INT_1, OldInt1);
}

ca semble fonctionner et là il n'y a pas de temps d'attente avec un while sur le timer
-Edité le Lundi 10 juillet 2006 à 11:20 par Xantares-
-Edité le Lundi 10 juillet 2006 à 11:23 par Xantares-

./Post n°6 Marquer comme non lu.

Jfg

Ecrit le: Lundi 10 juillet 2006 à 12:42

Administrateur

Groupe: Staff de Ti-Gen

Groupe: Orage Studio

Messages: 1260

Membre n°60

Inscrit le 23 février 2004

La fréquence des interruptions, c'est un détail que je ne connais pas.
Par contre, je ne peux pas m'empécher de te conseiller de ne surtout pas utiliser des "float". Sans exagérer, ton programme peux aller au moins 5x plus vite si tu utilises des "int".

Kill Mario

./Post n°7 Marquer comme non lu.

Xantares

Ecrit le: Lundi 10 juillet 2006 à 22:48