Sujets

1

DotNet / Création d'un bouton et gestion de l'événement pour le click

« le: Janvier 22, 2015, 06:01:06 pm »

Bonjour à tous (encore une fois), je me questionne sur comment créer un bouton en SFML. Je crois avoir trouvé en grande partie comment faire.

Ma class Button (Bulb pour HealthBulb, mais ce n'est pas très important)

class Bulb : SFML.Graphics.Transformable, SFML.Graphics.Drawable
{
        private SFML.Graphics.RectangleShape _BulbContainer;

        public event EventHandler BulbClicked;

        public Bulb(SFML.Graphics.Color Color)
        {
                this._BulbContainer = new SFML.Graphics.RectangleShape(new SFML.System.Vector2f(30, 80));
                this._BulbContainer.FillColor = SFML.Graphics.Color.Transparent;            
                this._BulbContainer.OutlineThickness = 1;
                this._BulbContainer.OutlineColor = SFML.Graphics.Color.White;
        }

        public void Update()
        {              
                if (this._BulbContainer.GetGlobalBounds().Contains(State1.MousePosition.X, State1.MousePosition.Y))
                {
                        if (SFML.Window.Mouse.IsButtonPressed(SFML.Window.Mouse.Button.Left))
                        {
                                if (this.BulbClicked != null)
                                {
                                        this.BulbClicked(this, null);
                                }
                        }
                }
        }

        public void Draw(SFML.Graphics.RenderTarget target, SFML.Graphics.RenderStates states)
        {
                states.Transform *= this.Transform;
                target.Draw(this._BulbContent, states);
                target.Draw(this._BulbContainer, states);
        }
}
 

Ma classe qui utiliser mon Bulb

class GUI : SFML.Graphics.Transformable, SFML.Graphics.Drawable
{
        private SFML.Graphics.RectangleShape _Background;
        private Widget.Bulb _HealthBar;

        public GUI()
        {
                this._Background = new SFML.Graphics.RectangleShape(new SFML.System.Vector2f(800, 100));
                this._Background.FillColor = new SFML.Graphics.Color(100, 100, 100);

                this._HealthBar = new Widget.Bulb(SFML.Graphics.Color.Red);
                this._HealthBar.Position = new SFML.System.Vector2f(100, 10);

                this._HealthBar.BulbClicked += new EventHandler(_HealthBar_BulbClicked);
        }
       
        void _HealthBar_BulbClicked(object sender, EventArgs e)
        {
                Console.Write("HealthBulb.Click");
        }
        //Reste de ma classe inutile pour ma question
}
 

Ce que je me demande se situe au niveau de la méthode Update de ma class Bulb. Cette méthode vérifie si la sourie est à l'intérieur des limites de mon Bulb et si c'est le cas, elle vérifie si j'appuie sur le bouton gauche de la souris et si oui, je lève mon événement ce qui, dans la classe GUI, appellera la méthode _HealthBar_BulbClicked(object sender, EventArgs e).

J'ai l'impression que ce sera lourd si j'ai plusieurs bouton à gérer sur mon même écran. Je penses à la plupart des jeux qui ont plusieurs bouton (inventaire, map, option, skills 1, skill 2, etc, ouvrir fenêtre de chat et ainsi de suite). Déjà que j'update mon GUI à chaque boucle pour l'afficher sur mon écran, si en plus dans mon GUI j'appelle plusieurs update de chaque contrôles (bouton, bulbe de vie, compétence active, etc), qui eux se mettent à jour aussi à chaque boucle pour vérifier si je clique ou non dessus, j'ai l'impression que ce sera lourd pour l'ordinateur, non? À moins que je ne m'y prenne pas de la bonne manière et qu'il y a un moyen beaucoup plus optimisé?

Merci d'avance.
Ah, et mes projets avance. Je devrais bientôt pouvoir vous montrer quelques trucs que j'ai réalisé!

2

DotNet / [Résolu] Suis-je sur la bonne voie pour bien programmer?

« le: Juin 26, 2014, 02:08:56 pm »

Bonjour à tous, cela fait quelques années que je ne suis pas venu ici (mes anciens message sont introuvables, est-ce que le forum aurait été remis à zéro?)

Enfin bref, je me suis (re)lancé dans le développement d'application graphiques avec le binding .Net puisque dans mes études et mon travail j'ai énormément touché à ce langage. Je me suis lancé depuis peu dans le développement d'un petit moteur de jeu via ce tutorial http://www.games-creators.org/index.php/Gestion_des_Game_States_en_C_plus_plus

Plus j'avance, plus je me demande si je suis sur la bonne voie dans ma manière de programmer. Je vois différents moyens de faire les choses et je me demandais si ma façon de faire est bonne ou s'il fallait plutôt revoir ma logique et recommencer d'une autre manière.

Ma classe IntroState, qui ne fait qu'afficher une image de fond, avec un rectangle qui passe d'opaque à transparent laissant apparaître cette image de fond (oui c'est laid, mais je suis encore en train de faire des tests en même temps que je développe mon moteur). En appuyant sur la touche Échap, on quitte l'application. En appuyant sur la touche Espace, on entre dans l'état FightState.

namespace SFML_Test1.Engine2
{
    class IntroState : GameState
    {
        private SFML.Graphics.Sprite _Background = null;
        private SFML.Graphics.Sprite _SFMLLogo = null;
        private byte _Fade = 255;
        private SFML.Graphics.RectangleShape _FadingRectangle = null;
        private SFML.Graphics.Text _Text = null;
        private Text _Copyright = new Text("© 2014", new SFML.Window.Vector2f(0, 580), 12);
       
        private System.Diagnostics.Stopwatch _Stopwatch = null;

        public override void Init()
        {
            this._Background = new SFML.Graphics.Sprite(new SFML.Graphics.Texture("mainmenu/menubg.jpg"));
            this._SFMLLogo = new SFML.Graphics.Sprite(new SFML.Graphics.Texture("mainmenu/sfml-logo-small.png"));
            this._SFMLLogo.Scale = new SFML.Window.Vector2f(0.5f, 0.5f);
            this._SFMLLogo.Position = new SFML.Window.Vector2f(800 - this._SFMLLogo.GetGlobalBounds().Width, 600 - this._SFMLLogo.GetGlobalBounds().Height);                      
            this._FadingRectangle = new SFML.Graphics.RectangleShape(new SFML.Window.Vector2f(800, 600));
            this._Text = new SFML.Graphics.Text("", new SFML.Graphics.Font("ARIAL.TTF"));

            Console.WriteLine("IntroState.Init()");
            this._Stopwatch = new System.Diagnostics.Stopwatch();
            this._Stopwatch.Start();
        }

        public override void Cleanup()
        {
            throw new NotImplementedException();
        }

        public override void Pause()
        {
            throw new NotImplementedException();
        }

        public override void Resume()
        {
            throw new NotImplementedException();
        }

        public override void HandleEvents(GameEngine ge)
        {
            if (SFML.Window.Keyboard.IsKeyPressed(SFML.Window.Keyboard.Key.Space))
            {
                Console.WriteLine("IntroState.KeyPressed(Space)");
                ge.ChangeState(new FightState());
            }
            if (SFML.Window.Keyboard.IsKeyPressed(SFML.Window.Keyboard.Key.Escape))
            {
                Console.WriteLine("IntroState.KeyPressed(Escape)");
                ge.Quit();
            }
        }

        public override void Update(GameEngine ge)
        {
            if (_Stopwatch.Elapsed.Milliseconds > 20)
            {
                if (this._Fade > 0)
                {
                    this._Fade--;
                    this._Stopwatch.Restart();
                }
            }

            this._FadingRectangle.FillColor = new SFML.Graphics.Color(255,255,255, _Fade);

            this._Text.CharacterSize = 55;
            this._Text.Origin = new SFML.Window.Vector2f(this._Text.GetGlobalBounds().Width / 2, this._Text.GetGlobalBounds().Height / 2);
            this._Text.Position = new SFML.Window.Vector2f(400, 100);
            this._Text.DisplayedString = "Engine v0.01";
            this._Text.Color = SFML.Graphics.Color.White;            
        }

        public override void Draw(GameEngine ge)
        {
            ge.Window.DispatchEvents();
            ge.Window.Clear();

            ge.Window.Draw(this._Background);

            ge.Window.Draw(this._Text);
            ge.Window.Draw(this._SFMLLogo);

            ge.Window.Draw(this._Copyright);          

            ge.Window.Draw(this._FadingRectangle);

            ge.Window.Display();            
        }
    }
}
 

La classe FightState ne se différencie pas énormément de la classe IntroState, je ne vais que poster ce qui est important, c'est à dire l'utilisation de mon GUI.

namespace SFML_Test1.Engine2
{
    class FightState : GameState
    {
        private GUI _Gui = null;

        public override void Init()
        {
            Console.WriteLine("FightState.Init()");

            this._Gui = new GUI(new SFML.Window.Vector2f(10, 440), new SFML.Window.Vector2f(250,150), SFML.Graphics.Color.Black);
        }

        public override void Draw(GameEngine ge)
        {
            ge.Window.DispatchEvents();
            ge.Window.Clear();

            ge.Window.Draw(this._Gui);

            ge.Window.Display();
        }
    }
}
 

La classe GUI implémente l'interface Drawable dans le but d'être directement affichable en tant que classe (et non avoir à afficher chaque élément de mon GUI  dans ma classe FightState). Cette Gui s'affiche

namespace SFML_Test1.Engine2
{
    class GUI : SFML.Graphics.Drawable
    {
        private SFML.Graphics.RectangleShape _Background = null;
        private SFML.Graphics.RectangleShape _LifeBar = null;

        public GUI(SFML.Window.Vector2f Position, SFML.Window.Vector2f Size, SFML.Graphics.Color BackgroundColor)
        {
            this._Background = new SFML.Graphics.RectangleShape(Size) { Position = Position, FillColor = BackgroundColor };
            this._LifeBar = new SFML.Graphics.RectangleShape(new SFML.Window.Vector2f(80, 20)) { Position = new SFML.Window.Vector2f(50, 500), FillColor = SFML.Graphics.Color.Green };
        }

        public void Draw(SFML.Graphics.RenderTarget target, SFML.Graphics.RenderStates states)
        {
            target.Draw(this._Background, states);
            target.Draw(this._LifeBar, states);
        }
    }
}
 

Alors voilà, en gros le moteur affiche l'état IntroState jusqu'à ce que je décide de changer d'état (ici en appuyant sur Échap ou sur Espace). Une fois dans l'état FightState, je boucle cet état (gestion des événements, mise à jour des valeurs et affichage à l'écran) et par dessus tout ce qu'affiche mon FightState, j'affiche mon GUI.

Je voulais donc savoir si ce que je faisais était bien ou si je devais tout revoir mon système. Pour le moment ce n'est que minime, mais si je me lance dans un gros projet (ce que je vais faire éventuellement), je ne veux pas arriver à un point ou ma base est mauvaise et devoir recommencer mon moteur de jeu presqu'entièrement.

Merci d'avance.