Discussion :

[screetch]

Hello,

Je m'interesse (comme 99% des codeurs du dimanche) aux jeux videos mais j'ai le gros defaut de toujours vouloir reinventer la roue (par exemple je n'utilise pas boost car c'est trop lourd pour le peu de metaprogramming que je fais)

Comme d'habitude j'ai voulu utiliser kekchose et je ressens le besoin inexplicable de le recoder moi meme a cause de micro-defauts (qui ont une certaines importance quand meme, c'est pas juste debile!)

Donc voila, dans mon petit moteur qui ne fait pour l'instant rien, j'ai codé un sequenceur c'est a dire un objet qui, independamment de la frame, va pouvoir faire tourner du code sur plusieurs frames.

Le but est de corriger le genre de defaut :
- je veux que mon panel se deplace de 10 pixels en 10 pixels
- je le mets dans une boucle for
- mais comme l'ecran n'est pas rafraichi je ne vois que le resultat final
- donc dans la boucle for je rafraichis l'ecran
- ah mais oui mais le jeu est en "pause" pendant ce temps, la physique n'est plus mise a jour ni rien! je n'avais pas pensé a ca.

Pour contrer ce "probleme" toutes les taches a effectuer sont donc mise dans un sequenceur.

En gros le sequenceur est une classe singleton Updater qui contient une liste de IUpdatable.

Le sequenceur appelle a chaque frame pour chaque objet la methode update(double time); de chaque IUpdatable.

Si l'updatable a fini son travail i lrenvoie true et on passe a la suite.
Sinon, il reste dans la liste et la methode sera encore appelée au prochain tour.


je compte utiliser cela tres tres beaucoup! Le probleme c'est que du coup c'est assez difficile a creer (faire un arbre de IUpdatable, c'est chiant).

Du coup je pensais, au lieu de faire simplement comme les autres et de prendre lua, creer un language de script se traduisant par un arbre de IUpdtabale.

Donc une fonction pourrait (enfin) s'etendre sur plusieurs frame, avec la possibilité egalement de rendre la main au moteur avec l'instruction yield. par exemple, pour le cas precedent :

un langage serait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
{
    for(i in [1..10])
    {
        panel->move(+10,0); //deplaces le panel de 10 pixels a droite
        yield;                      // on reprendra a la frame suivante
    }
}

Je cherche un retour d'experience sur des gens qui auraient utilise un sequenceur dans leur developpement et/ou lua pour soit me dire que ce que je fais est inutile, soit me dire que c'est trop cool ^^

qu'en pensez vous ? suis je (de nouveau) en train de recreer un truc connu depuis 10 000 ans ?

[Laurent Gomila]

J'ai du mal à saisir le problème qui t'a amené à penser à tout ça. Quand je veux déplacer un objet je lui attribue une vitesse, puis je le déplace à chaque frame selon cette vitesse et le laps de temps écoulé, ça me garantit un déplacement constant indépendamment du framerate.

Alors est-ce que c'est moi qui ai mal compris ton problème, ou toi qui a trouvé une réponse tordue à un problème très simple ?

[screetch]

Il ne faut pas se focaliser sur l'exemple lui même.

Mais comment ton moteur mets il a jour la position du paneau ?

il y a un point d'entree quelque part.

Autre exemple :

je souhaite baisser le volume de la musique puis lancer une nouvelle musique. Comments ferais tu ca ? tu lui colles pas uen vitesse cette fois ci ! ^^

Mon probleme est de pouvoir effectuer des actions qui s'etendent sur la duree et qui ne seront pas fini avant la fin de la frame.

[bafman]

I
je souhaite baisser le volume de la musique puis lancer une nouvelle musique. Comments ferais tu ca ? tu lui colles pas uen vitesse cette fois ci ! ^^

oui.
tu lui met une vitesse de réduction proportionnelle au temps écoulé entre chaque frame.
ce que tu veut faire, c'est simplement refaire, via un langage de scripts, ce que fait tout moteur via la fameuse méthode update...

[screetch]

Ben oui! je ne vois pas ou est le probleme, je souhaite decrire les actions (les IUpdatable) dans un langage de script, ce qui me permet d'ecrire des actions complexes (i.e. composees de plusieurs instructions)

Ce que je souhaite faire c'est bel et bien decrire mon arbre de IUpdatable d'une maniere lisible.

[Laurent Gomila]

Je comprends bien le problème, et j'ai presque toujours à implémenter quelque chose pour gérer ça, mais ça ne nécessite jamais de tourner en parallèle et avec un langage de script

bafman a bien expliqué la chose : à partir du moment où tu gères bien tes updates, càd en prenant en compte le temps écoulé, tu n'as pas besoin de tout ça.

[Laurent Gomila]

Ben oui! je ne vois pas ou est le probleme, je souhaite decrire les actions (les IUpdatable) dans un langage de script, ce qui me permet d'ecrire des actions complexes (i.e. composees de plusieurs instructions)

Ce que je souhaite faire c'est bel et bien decrire mon arbre de IUpdatable d'une maniere lisible.

Donc ton langage ne servirait pas à résoudre un problème, mais à simplifier les descriptions de "séquences" ?

[ash.ice.loky]

Peu importe la raison (j'avou que ton probleme ne me semble pas vraiment en etre un) mais je t'encourage a te lancer dans la realisation d'un langage de script si tu aimes reinventer la roue.

Pour l'avoir fait, c'est un exercice tres instructif, mais qui est bien plus long que de "simples" smart pointeur.

[screetch]

De ce que je lis, vous avez un truc genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Sound : public IUpdatable
{
  // variables propres au son
  float volumeSpeed;
  float3 position;
  float3 speed;
 
  //..
  bool update(double time)
};
 
bool Sound::update(double time)
{
  //update la position
  position += speed*time;
  //update le volume
  volume += volumeSpeed*time;
 
  //joue le son
  decode();
  buffer();
  return (finished);
}

C'est pile poil ce que je souhaite eviter.

Je ne veux pas avoir 14 fonctionnalités effectuées a la suite dans le update.

pour cela, je dis que ce n'est pas le Son qui doit savoir se deplacer, mais un objet externe dont le seul but est de deplacer le son dans l'espace au moment opportun. Un autre objet se charge de regler le volume sur le temps. Ce n'est PAS le son qui regle son propre volume dans l'update.



Ce qui va se passer alors c'est une complexite infernale de choses a updater, lorsque le son est fini il doit prevenir le reglage du volume que ca sert pas des masses... bref, un arbre de trucs a updater qui est illisible.



Je souhaite donc pouvoir decrire cet arbre d'Updatables de maniere correcte.

Pour cela, un langage de script serait utile car il transformerait une sequence d'instructions en chaine d'Updatables imbriques les uns dans les autres, et je peux decrire de maniere simple des actions complexe.

Pour reprendre l'exemple plus haut, le son ne sait pas s'updater, ce n'est qu'une description, il a des accesseurs pour modifier ses parametres (le son, le pitch). Une fonction externe vient modifier le son toute les frames, le son n'a pas connaissance de cetet notion de frame.

De meme, le paneau d'interface ne sait pas se deplacer, il sait s'afficher a une position. Un effet exterieur modifie la position.

Vous voyez donc le nombre de petites entites a manipuler avant que ca commence a ressembler a quelque chose =)

Le but est donc de lire un fichier script qui donne une sequence d'actions

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
{
  local volume = sound.getVolume()
  for(i in 1..0 step 0.1)
  {
    sound.setVolume( i*volume ); // ici independant du framerate, mais on peut faire mieux
  }
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
{
  local volume = sound.getVolume()
  local const totaltime = 100;
  local timetowait = totaltime; //100ms le volume passera a 0
  local time = 0;
  while(timetowait > 0)
  {
    fade = timetowait/totaltime;
    sound.setVolume( fade*volume );
    time = yield(); // on attend la prochaine frame et on recoit le temps ecoule
    timetowait -= time;
  }
}

L'interet serait bien evidemment d'avoir beaucoup de ces choses tournant ensemble, pas juste 1 seul. Ceci est l'objet qui se charge de regler le volume du son, une autre methode existe pour deplacer le son, etc.

Peut etre vous voyez mieux ?

[bafman]

un système d'evolver qui point vers un objet à faire évoluer au fur et a mesure du temps te donnerai le même résultat, en étant non intrusife dans l'architecture, et en étant nettement plus simple à réaliser.

[screetch]

pardon ?

[bafman]

tu fait une classe de type evolver. c'est elle qui évolue au cours du temps (et non pas ton son, même si lui aussi peut le faire.
ensuite, tu crée plusieurs sous classe d'evolver, chacune prenant en compte une préoccupation donné.
ca donne un truc du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
class Sound
{
    // fait plein de truc strictement lié à la gestion du son
}
 
class Evolver
{
    virtual void Update(float elapsedTime) = 0;
}
 
class EvolverSoundFadeOut : public Evolver
{
    Sound* sound;
    void Update(float elapsedTime)
    {
        // calcul le fading sur le son
    }
}
 
class EvolverSoundChangePosition : public Evolver
{
...
}

ainsi, tu peut ajouter des comportement à ton son, sans pour autant changer son design (d'où le fait que se soit non intrusif)

[screetch]

Exactement! ca c'est fait!

en fait mon son sait quand meme "s'updater" pour remplir le buffer et tout, mais il ne gere pas son volume.

Mais mainetnant le probleme c'est : comment rendre ca "lisible" ? comment voir ce qu'il y a d'actif, ce que... etc.

d'ou l'idee de faire un langage permettant de generer l'arbre des evolver, depuis une description qui est lisible pour un codeur.

Ce que tu proposes comme evolver, moi je l'ai genere avec ma fonction.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
{
  local volume = sound.getVolume()
  local const totaltime = 100;
  local timetowait = totaltime; //100ms le volume passera a 0
  local time = 0;
  while(timetowait > 0)
  {
    fade = timetowait/totaltime;
    sound.setVolume( fade*volume );
    time = yield(); // on attend la prochaine frame et on recoit le temps ecoule
    timetowait -= time;
  }
}

cette fonction est precisement un "evolver de volume", ca me parait lisible (parce que je suis codeur hein, un designer aimerait pas), je controle le sequenceur donc je peux placer des "breakpoints" tester etc etc

c'est a dire que au lieu de creer la classe SoundVolumeEvolver en C++, j'utilise des briques de bases (instructions) pour creer un evolver plus complexe.

Cela est il plus clair ?

[HanLee]

Ce que tu peux faire, c'est avoir une liste de fonctions update plutôt, avec effets de bords qui dépendent du temps dernièrement écoulé <float elapsedTime>.

Ensuite, en C++, normalement tu vas avoir une masse de fonctions qui servent à mettre à jour des choses, qui dépendent de pleins de paramètres, et aussi du <float elapsedTime>.

Ca donne ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
typedef boost::function<void (float)> update_function;
 
std::vector<update_function> UpdateFun_list;
 
// Tu as plein de fonctions comme ça
void update_sound(Sound* s, float);
void update_playerposition(Player* p, float);
...

Ensuite, pour enregistrer des fonctions :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
UpdateFun_list.push_back( boost::bind(&update_sound, pSound, _1) );
UpdateFun_list.push_back( boost::bind(&update_playerposition, pPlayer, _1) );

Et pour mettre à jour...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
// Connaissant le temps écoulé elapsedTime
for (size_t i = 0; i < UpdateFun_list.size(); ++i)
    UpdateFun_list[i]( elapsedTime );

[screetch]

Plouf plouf,

j'ai trouve un autre moyen de formuler ce que je voulais dire (au cas ou ca debloque des souvenirs) :

Je souhaite pouvoir coder les methodes "update" et autres "evolvers" dans un langage de scripts, pour pouvoir coder des evenements compliques a partir de briques de bases, Les briques de bases sont ecrites en C++ et publiees pour le langage de script.

A partir de la description, le langage genere un "evolver".

Ceci est tres similaire au UnrealScript (http://unreal.epicgames.com/UnrealScript.htm)

voila pit etre c'est plus clair ^^