Adding a "Tag" to a sprite: Possible

[eyeliner]

First, I'll explain what I want to do:

I'm currently using lists to store my sprites, so that I use a foreach loop and draw all the items in a List<Sprite>.
It works great. For drawing, of course.

Thing is, if I want to do anything more to them, say like test if the mouse is over one specific sprite.
It would be great if there's a way to add a tag (or something, for that matter), that we could use to differenciate the sprites, using a list would be even more great.

In my case, I'm specifying the index of a sprite on the list to shutdown my app. Ok, I can live with it.
But when the app grows (and I intend on doing something very much mouse based), it would be great if I could do something like:

foreach (Sprite s in sprites)
    if (s.GetGlobalBounds().Contains(mouseX, mouseY)&&s.Tag =="whatever")
        {
                //Do something
        }
 

I'm really not sure about the difficulty in implementing such a thing and if a thing exists, I apologise. If it is something that can be added by anyone less enlightned (like myself), I surely wouldn't mind doing it.

Can anyone tell me? Thanks.

[Laurent]

That's a really limited point of view, and such things will never make it into SFML anyway. SFML sprites should not, and will never, help you implement your high-level collision logic.

Instead, you should think about how you could implement such a system on top of SFML sprites. Not in them.

For example, you could create a class derived from Sprite that checks its collisions itself and triggers an event when it collides. Then you can attach a collision handler when you create the sprite.

[eyeliner]

Understood. I don't think I'm quite there yet to pull off such a thing, but I got the point you are trying to get across.

Thanks Laurent.
EDIT:
Thanks muchly for the point in the right direction! Made it work by making a class that derives from sprite. I added a Tag.

Now to make a collision checker.

[Nexus]

I would even recommend to build a high-level logic class around Sprite, not derived from it. That is, one that contains the sprite as a member and encapsulates it. The sprite is just a visual representation of a game entity and not the entity itself.

This may sound like more work in the beginning, but the separation of graphics and game logic pays off as soon as the project grows. There have been a lot of design discussions about this point, you could search for older threads if you're interested.

[Hapax]

eyeliner, try this:

class TaggedSprite : public sf::Sprite
{
public:
        std::string tag;
};

Then use TaggedSprite instead of sf::Sprite. You can then access an internal string called tag for any use that you like.

Here's an complete (but simple) example:

(click to show/hide)

#include <SFML/Graphics.hpp>
#include <string>

class TaggedSprite : public sf::Sprite
{
public:
        std::string tag;
};

int main()
{
        sf::RenderWindow window(sf::VideoMode(800, 600), "");

        sf::Texture texture;
        if (!texture.loadFromFile("image.png"))
                return EXIT_FAILURE;
        std::vector<TaggedSprite> taggedSprites(10);

        unsigned int currentSpriteIndex{ 0 };
        for (auto& taggedSprite : taggedSprites)
        {
                taggedSprite.setTexture(texture);
                taggedSprite.setPosition(50 * currentSpriteIndex + 10, 10);
                ++currentSpriteIndex;
        }

        taggedSprites[0].tag = "word";
        taggedSprites[1].tag = "a";
        taggedSprites[2].tag = "text";
        taggedSprites[3].tag = "string"; // length of 6
        taggedSprites[4].tag = "key";
        taggedSprites[5].tag = "tag";
        taggedSprites[6].tag = "example"; // length of 7
        taggedSprites[7].tag = "something"; // length of 9
        taggedSprites[8].tag = "else";
        taggedSprites[9].tag = "sfml";

        while (window.isOpen())
        {
                sf::Event event;
                while (window.pollEvent(event))
                {
                        if (event.type == sf::Event::Closed)
                                window.close();
                }

                window.clear();
                for (const auto& taggedSprite : taggedSprites)
                {
                        if (taggedSprite.tag.length() < 6) // only display taggedSprites that have a tag that is shorter than 6 characters
                                window.draw(taggedSprite);
                }
                window.display();
        }

        return EXIT_SUCCESS;
}

I read Nexus' reply just as I was about to post this and realised that I think he's right. I'm still going to post this example as it may help you see how easy/useful inheritance can be

EDIT: Just saw your own modified post that stated that you've figured it out already. Go you!

[eyeliner]

I sure am! I just need a bit of time to deal with and search for with the particulars. Adding a tag ended up being way easier than I first thought.
Of course, I need to create a sprite in a bit different way, but it's okay (for 3 lines of code, at least).

My main hardships are the names of what to look for. :p

Thanks, Hapax, I'll have to translate that to C#. And yeah, I figured how to do it, but I can't create a sprite like:

Code: [Select]

nSprite spr = new nSprite(new Texture("image.png");

I have to resort to this:

Code: [Select]

nSprite.Texture = new Texture("image.png");
nSprite.Tag = "myTag";

But it's not too bad.

[Hapax]

I'm really sorry; I didn't even notice this was in the DotNet forum 

I found the same problem. You can see in my code that I also set the texture after creation of the "tagged sprite".

You should probably, as Nexus suggested earlier, create a class that has an sf::Sprite as a member and include the tag inside your new class. That way, you can add more things to it that aren't directly related the image. The initialisation should work as normal then too.

[eyeliner]

That's OK. When trying to help, sometimes overlooks happen.

Now, regarding Nexus' advice (and yours), I'm trying to find out how to do such a thing.
And having a hard time to find good examples. But I'm stubborn.

[Ztormi]

He is referring to splitting your class into logical components as in Component pattern.

The simplest practical example would be:

 

public class MySprite
    {
        // this is the sfml sprite
        public Sprite Sprite { get; set; }

        public string Tag {get; set;}

        public MySprite()
        {
        }
        public MySprite(Texture t)
        {
            Sprite = new Sprite(t);
        }
    }

 

MySprite spr = new MySprite(new Texture("..."));

[zsbzsb]

If you really don't want to use the component pattern and really just want a tag added to a sprite you could exploit object inheritance + extension methods. However, as Nexus said, you should really just prefer a high level composition class around SFML objects.

(click to show/hide)

    class TaggedSprite : Sprite
    {
        public object Tag { get; set; }

        public TaggedSprite() : base() { }
        public TaggedSprite(Sprite copy) : base(copy) { }
        public TaggedSprite(Texture texture) : base(texture) { }
        public TaggedSprite(Texture texture, IntRect rectangle) : base(texture, rectangle) { }
    }

    static class ExtensionMethods
    {
        public static object GetTag(this Sprite Sprite)
        {
            return Sprite is TaggedSprite ? ((TaggedSprite)Sprite).Tag : null;
        }
        public static bool SetTag(this Sprite Sprite, object TagValue)
        {
            if (Sprite is TaggedSprite)
            {
                ((TaggedSprite)Sprite).Tag = TagValue;
                return true;
            }
            else return false;
        }
    }

    static class Example
    {
        static void Main()
        {
            // create a tagged sprite
            Sprite sp = new TaggedSprite();

            // attempt to set the tag on base Sprite type
            // note: if the 'sp' variable does not inherit from TaggedSprite this will return false
            sp.SetTag("mytag");

            // attempt to read the tag value
            // note: if the 'sp' variable does not inherit from TaggedSprite this will return null
            object tag = sp.GetTag();
        }
    }

This would also allow your original code to work like the following.

(click to show/hide)

foreach (Sprite s in sprites)
    // notice the GetTag() function
    if (s.GetGlobalBounds().Contains(mouseX, mouseY)&&s.GetTag() =="whatever")
        {
                //Do something
        }

[eyeliner]

This is all levels of amazing! Thanks! After reading your code (Ztormi, and zsbzsb), I think I now understand. I was actually hacking away with some positive results.

I wouldn't go where you guys are so fast (there's the difference between those who know and those who would like to know), but you guys helped me immensely for my future. This will prove quite handy if I ever get such a need in other classes.

Thanks, all.