Discussion :

[poussinphp]

Bonjour,

Je suis sur l'elaboration de mon petit moteur 2D et je rencontre quelques soucis sur les timers. j'ai regardé les divers tuto sur le sujet mais je vois pas trop comment l'appliquer en sdl .net. Le site officiel propose un exemple mais avec l'architecture de mon moteur je ne vois pas comment l'implémenter.

J'ai une interface IGAMESTATE à laquelle j'hérie un GAMESTATE.

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
 
    public sealed class GameStateManager
    {
        #region DECLARATION
 
        private static GameStateManager instance = new GameStateManager();
        IGameState _currentState;
        IGameState _nextState;
        bool _running;
 
        #endregion
 
 
        #region METHODES STATIQUES
        /// <summary>
        /// Evenements
        /// </summary>
        public static void Evenements()
        {
            instance.evenements();
        }

Ce code est utilisé dans mon main :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
            GameStateManager.ChangeState(new Niveau());
            while (GameStateManager.Running)
            {
                GameStateManager.CheckState();
                GameStateManager.Evenements();
                GameStateManager.Actualisation();
                GameStateManager.Affichage();
                ScreenManager.Surface.Update();
            }
        }

et mon gamestate gere les niveau (pour le moment c'est un unique niveau codé en dur pour faire tourner l'ensemble de mes class / methodes)
Je l'utilise de cette façon :

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
25
26
27
 
        /// <summary>
        /// Gestion des evenements
        /// </summary>
        public void Evenements()
        {
            if (!Events.Poll())
            {
                return;
            }
            // On quitte le programme avec Echap
            KeyboardState _keyState = new KeyboardState();
            if (_keyState.IsKeyPressed(Key.Escape))
            {
                GameStateManager.Quit();
                return;
            }
            foreach (Entite entites in _entites)
            {
                entites.Evenement();
            }
            // Actions
            foreach (Entite entites in _entites)
            {
                Collision.MapSprite(_carte, entites);
            }
        }

Le problème c'est comment implémenter une gestion du temps? J'ai vu qu'il y avais une propriété dans events.fps (propriété en get / set) permettant de gerer les rafraichissements ainsi qu'un evenement evenets.ticks mais comment inserer ça dans mon moteur?

Auriez vous une idée? Merci

[fearyourself]

Je suis désolé mais je ne comprends pas tout.

Est-ce que tu t'intéresses à des timers dans le sens : "Dans 2 secondes, fait un appel à la fonction fct" ou à la gestion du temps dans le sens "Ca fait combien de temps que mon tir a été fait ?"

Ensuite, tu parles de ton problème de l'intégration du timer mais comment veux-tu l'intégrer, à quel niveau ?


Ensuite :

FPS : c'est utilisé pour définir le nombre d'itérations que tu veux par seconde par le système d'événement va appeler le handler que t'as mis pour l'événement Tick.

Jc

[poussinphp]

En faite quand je parle de "timer", je veut parler du nombre d'itérations / seconde que je veut gerer.

Le déplacement de mes personnages est facteur du nombre d'iteration ou du nombre de tours de boucle (while) par seconde.

J'aimerais régler la vitesse globale de mon jeu (à savoir, regler la vitesse de ma boucle principale).

[coyotte507]

En faite quand je parle de "timer", je veut parler du nombre d'itérations / seconde que je veut gerer.

Le déplacement de mes personnages est facteur du nombre d'iteration ou du nombre de tours de boucle (while) par seconde.

J'aimerais régler la vitesse globale de mon jeu (à savoir, regler la vitesse de ma boucle principale).

Salut,

je connais deux solutions pour réguler la vitesse d'un jeu.

Tu peux par exemple utiliser SDL_GetTicks(): SDL_GetTicks() te donnes le temps en millisecondes depuis je crois le début du programme.

Admettons que tu veuilles exécuter une boucle toutes les 30 ms:

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
//On fait d'abord un écart de 30 ms pour être sûr d'exécuter la boucle tout de suite
Uint32 lasttime = SDL_GetTicks() - 30;
 
//Là c'est ta boucle que tu veux réguler
while (condition_de_la_boucle)
{
    //Si ça fait moins de 30 ms depuis la dernière itération, on passe
    if (SDL_GetTicks()-lasttime < 30)
    {
       //évite d'utiliser 50-100% du cpu
       SDL_Delay(1);
       //et on revient au début de la boucle
       continue;
    }
 
    //Sinon on remet lasttime à jour
    lasttime = SDL_GetTicks();
 
    ...
    ...
}

Voilà pour SDL_GetTicks()!


L'autre méthode consiste à utiliser une fonctionnalité de la SDL pour appeler une fonction à l'intervalle qu'on veut, mais ça n'a pas l'air de correspondre à tes envies

[fearyourself]

Salut,

je connais deux solutions pour réguler la vitesse d'un jeu.

En effet, cette solution fonctionne mais sous SDL Net, tu peux faire quelque chose de plus fin.

Il suffit de définir un handler dans le gestionnaire Tick et ensuite définir la valeur de FPS pour avoir ce nombre d'appels par seconde au handler.

Exemple :

Code :

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

1
2
3
 
    Events.Tick += new EventHandler<TickEventArgs>(this.Tick);
    Events.Fps = 5;

et une fonction comme ceci :

Code :

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

1
2
3
4
5
6
 
private void Tick(object sender, TickEventArgs e)
{
    screen.Fill(Color.FromArgb(rand.Next(255), rand.Next(255), rand.Next(255)));
    screen.Update();
}

Je suppose que le système fera de son mieux pour appeler le bon nombre de fois la fonction mais si tu mets trop de code, il pourrait se retrouver en retard.

Normalement, on ne fait pas cela. On gére la gestion des mouvements en fonction du temps et non du nombre de FPS. Donc avant chaque mouvement, on vérifie l'horloge par rapport au dernier mouvement et on calcule la nouvelle position.

Jc

[poussinphp]

Normalement, on ne fait pas cela. On gére la gestion des mouvements en fonction du temps et non du nombre de FPS. Donc avant chaque mouvement, on vérifie l'horloge par rapport au dernier mouvement et on calcule la nouvelle position.

Justement, j'aimerais arriver à ce résultat.
Pour être précis, je voudrais faire une gestion du rafraichissement des surface en fonction du FPS mais faire la gestion des actions (events) en fonction du TEMPS. (à confirmer si c'est la bonne méthode, c'est mon idée sur le sujet pour le moment).

Le soucis c'est que je ne sais pas ou inclure ça...
Ma librairie est une DLL est elle doit fournir l'ensemble des elements au "jeu" mais elle doit aussi être totalement indépendante du jeu.

Le jeu utilise des fonctions d'un moteur, c'est au moteur de gerer les APIs qu'il utilise. (en bref, mon "main.cs" ne doit pas contenir de SDL ou autre. Simplement des fonctions de ma librairie ou du standard c#).

A la limite, je pourrais mettre dans le niveau.cs (car il seras automatisé depuis un script lua) mais pas dans le main.