(SFML) Issues with inheritance (C++)

Question

So, I'm using SFML and I'm trying to setup an entity class and a player sub-class that inherits from it, but this is my first time working with inheritance and I'm having issues: First, I have an AssetManager class that I cobbled together from different sources, since I don't quite understand how they work yet:

AssetManager.h:

class AssetManager {
public:
    AssetManager();
    
    static sf::Texture& LoadTexture(std::string const& path);
    static sf::SoundBuffer& LoadSoundBuffer(std::string const& path);
    static sf::Font& LoadFont(std::string const& path);

private:
    std::map<std::string, sf::Texture> m_Textures;
    std::map<std::string, sf::SoundBuffer> m_SoundBuffers;
    std::map<std::string, sf::Font> m_Fonts;

    static AssetManager* sInstance;
};

But you can only need to see the part relating to textures, here is that part from AssetManager.cpp:

AssetManager* AssetManager::sInstance = nullptr;

AssetManager::AssetManager() {
    assert(sInstance == nullptr);
    sInstance = this;
}

sf::Texture& AssetManager::LoadTexture(std::string const& path) {

    auto& texMap = sInstance->m_Textures;
    auto pairFound = texMap.find(path);

    if (pairFound != texMap.end()) {
        return pairFound->second;
    }
    else {
        auto& texture = texMap[path];
        texture.loadFromFile(path);
        return texture;
    }

}

Then an object of that class is included inside a Sprite class, that facilitates declaring sprites for me.

Sprite.h:

class Sprite {
public:
    AssetManager manager;
    sf::Texture m_Texture;
    sf::Sprite m_Sprite;

    sf::Vector2f sprite_scale;
    sf::Vector2u original_size;
    sf::Vector2f texture_size;

    Sprite(std::string path,sf::IntRect rect,sf::Vector2f size);
    
};

Sprite.cpp:

Sprite::Sprite(std::string path, sf::IntRect rect, sf::Vector2f size) {
    m_Texture = sf::Texture(AssetManager::LoadTexture(path));
    m_Sprite.setTextureRect(rect);
    m_Sprite.setTexture(m_Texture);

    original_size = m_Texture.getSize();

    texture_size.x = static_cast<float>(original_size.x);
    texture_size.y = static_cast<float>(original_size.y);

    sprite_scale.x = size.x / texture_size.x;
    sprite_scale.y = size.y / texture_size.y;

    m_Sprite.setScale(sf::Vector2f(sprite_scale.x, sprite_scale.y));
    m_Sprite.setOrigin(sf::Vector2f(original_size.x / 2, original_size.y / 2));

}

Then, an object of the Sprite class is itself included within an Entity class.

Entity.h:

class Entity {
public:
    Sprite entity_sprite;
    int health;
    float speed;
    bool collision = false;

    bool entity_collision(sf::Sprite entity2_sprite);// Entity.cpp only contains the declaration of this function so far so no need to post it.
    

};

Now, for a reason I don't understand, I'm not able to directly assign any arguments to the entity_sprite object when declaring it, and I'm only able to declare it with no arguments, despite the class having not a default constructor. However I am able to get around it using assignment: Entity entity_sprite = Entity("res/wildcard.png", { 0,0,36,63 }, { 36,63 });

But this isn't the main issue, and using the Entity class directly is not what I'm trying to do, I'm trying to write the Player sub-class and use that instead:

Player.h:

class Player:public Entity {
    Player() {
        entity_sprite = Sprite("res/wildcard.png", { 0,0,36,63 }, { 36,63 });
    }
};

Now I'm once again not able to directly assign arguments to the object directly, because the call of an object of a class type without appropriate operator() or conversion function to pointer-to-function type (Interestingly enough if I go back to the Entity object and assign the arguments there and pretend the errors don't exist, the error produced by the Player class changes to Too many arguments' and 'Too many initializers

This is getting too confusing.

Nonetheless, I am once again able to get around it using assignment, exactly the same as before, except this time I get an error saying the default constructor "Entity" cannot be referenced -- its a deleted function., so I go back to the Entity class and add an empty constructor like this: Entity() { } but then this constructor gives me another error saying no default constructor exists for class "Sprite", even though the Entity class doesn't exactly inherit from the Sprite class, so I go back even further to the Sprite class and give that an empty constructor: Sprite(){}, and the errors seemingly disappear, that is until I declare a Player object in the main.cpp file and try to compile and get a debug error pointing to the following line in AssetManager.cpp: assert(sInstance == nullptr);

So many problems for such a seemingly simple task, how do I pull myself out of this?

Answer 1

Ok, after consulting the SFML Forums, I have refactored the code to the following:

Sprite.h:

#include "AssetManager.h"

class Sprite{
public:
    sf::Sprite m_sprite;

    sf::Vector2f sprite_scale;
    sf::Vector2u original_size;
    sf::Vector2f texture_size;

    Sprite(){}
    sf::Sprite set_sprite(sf::Texture& tx, sf::IntRect rect, sf::Vector2f size);
};

Sprite.cpp:

#include "Sprite.h"

sf::Sprite Sprite::set_sprite(sf::Texture& tx, sf::IntRect rect, sf::Vector2f size) {

    sf::Sprite spr(tx);

    spr.setTextureRect(rect);

    original_size =tx.getSize();

    texture_size.x = static_cast<float>(original_size.x);
    texture_size.y = static_cast<float>(original_size.y);

    sprite_scale.x = size.x / texture_size.x;
    sprite_scale.y = size.y / texture_size.y;

    spr.setScale(sf::Vector2f(sprite_scale.x, sprite_scale.y));
    spr.setOrigin(sf::Vector2f(original_size.x / 2, original_size.y / 2));

    return spr;
}

Entity.h:

#pragma once
#include "Sprite.h"
#include "collision.h"
#include "Timer.h"

class Entity {
public:
    Sprite spr;
    sf::Sprite entity_sprite;
    int health;
    float max_speed;
    sf::Vector2f speed;
    sf::Vector2f direction;
    float acceleration;
    bool collision = false;
    timer t;
    float acc_time;
};

Player.h:

#pragma once
#include "Entity.h"

class Player:public Entity {
public:
    Player();
    float acc_time = t.accumulate_time();
    void keyboard_controls();
    void mouse_controls(sf::Vector2f cursor);
};

Player.cpp:

#include "Player.h"
#include <math.h>


Player::Player() {
    
    speed = { 0,0 };
    acceleration = 2;
    max_speed = 500 + acceleration;
    entity_sprite = spr.set_sprite(AssetManager::LoadTexture("res/wildcard.png"), { 0,0,60,63 }, { 60,63 });
}

In short, the Sprite class' constructor is replaced with a method that has the same exact role, that way I can simply declare a Sprite object with no parameters inside the Entity class, and I won't have any issues with the derived Player class since I won't be asked to create default constructors for both the Sprite and Entity classes.