I have been working on a 2D platformer for some time now, and I've managed to lay out the basic framework pretty well. Right now I'm however

facing a problem. I'm trying to implement classes for things like animation, physics, input and AI. Due to their nature they need to be able to edit

the attributes of their "owner" (I don't know that proper word, but I mean the class that has instantiated it (it being physics for example)).

I know the editing can't be done directly, so I though about passing the pointer to the "owner" object to the update function in the target class, but I don't know where I can get this pointer from.

I also drew a rough illustration of the relevant class hierarchy to help explain my point (vertical arrows represent inheritance (or the "is a" -relationship) and horizontal arrows represent a "has a" -relationship (composition I believe it's called)).

My idea of the class hierarchy:

http://i.imgur.com/ytUZcnv.png?1

Also here's some relevant code (I've removed the irrelevant parts):

GameObject class (header):

class GameObject
{
public:
    GameObject();
    virtual ~GameObject();

    virtual void            Draw(sf::RenderWindow& window);
    virtual void            Update(sf::Time& time);

    virtual void            SetPosition(float x, float y);
    virtual sf::Vector2f    GetPosition() const;

    virtual bool            GetIsMoving() const {return isMoving;}
    virtual void            SetIsMoving(bool val) {isMoving = val;}

    virtual bool            IsAnimated() {return animated;}
    virtual void            SetAnimated(bool val) {animated = val;}

private:
    sf::Sprite              sprite;
    sf::Texture             texture;
    bool                    isMoving;
    bool                    animated;
protected:
    Animation               Anim;
    Physics                 Phys;
};

Player class (header):

class Player : public GameObject
{
public:
    Player();
    ~Player();

    void     Update(sf::Time& time);
    void     Draw(sf::RenderWindow& window);

    float    GetYVelocity() const;
    void     SetYVelocity(float yVelocity) {this->yVelocity = yVelocity;}
private:
    float    yVelocity;
    int      jumpHeight;
};

Physics class (header):

class Physics
{
public:
    Physics();
    ~Physics();

    void     Update(sf::Time& time);

    float    GetGravity() {return gravity;}
    void     SetGravity(float gravity) {this->gravity = gravity;}
private:
    float    gravity;
protected:

};

Physics class (source):

void Physics::Update(sf::Time& time)
{
    static bool isLoaded = false;

    if (!isLoaded)
    {
        std::cout << "Physics loaded!" << std::endl;
        isLoaded = true;
    }
    //Let's say I wanted to edit the player's yVelocity here, what would I do?
}

Physics::Update is called from Player::Update by Phys.Update(time).

I'd love to get this resolved as it has effectively halted all progress on the game, thank you.

Would it not be better if the physics class holds all the information involving the physical condition of a game object such as velocity, gravity and have the physics class hold all the methods revolving around this specific topic. This way, the Update function, could also tell the physics object: "Dude, see if you need to alter our velocity".

This might be a silly way to do it since I am not an expert, but that is how I would have done it at a first glance.

PS: Point it down if it is a stupid suggestion, this way I know I was being silly. *grins*

That does actually sound like a good idea as it would help decrease the size of the Player class for example, but what would I do if, say the Input class detected a key press and wanted to change the player's velocity or position, which is stored inside the Physics class, maybe I'm overseeing something here but I still see the issue of one class modifying the other?

To be completely honest here, I didn't understand many of the things related to the Observer pattern (I'll definitely keep it in mind though), I understood the point the writer in the second link made, but that's about it. I'm still new to programming so I'll have to implement things that I can completely comprehend, even if they're inefficient and potentially dangerous, and then learn more advanced things as I go.

My current plan is to have the object pointer passed to the constructors of the various classes like you said earlier, so they can modify the owner object's attributes and access it's methods, but I didn't really understand what you meant with weird depencies.

Here is some code (not actual) of what I meant by that.

GameObject.h:

class GameObject
{
public:
    GameObject();
    virtual ~GameObject();

private:
    sf::Sprite              sprite;
    sf::Texture             texture;
    bool                    isMoving;
    bool                    animated;
protected:
    Animation               Anim(this);
    Physics                 Phys(this);
};

For the player there would also be Input Input(this); and for the enemy: AI AI(this)

And then take the Input constructor for example:

Input::Input(GameObject* obj)
{
      // If I understood correctly I need to create a pointer inside the Input class and set its address to the GameObject pointer's address here?
}

So my plan is to also update each aspect individually, so Player::Update would look like this (again not actual code):

Player::Update(sf::Time& time)
{
    ...
    ...
    ...
    Input.Update(); // For the Enemy::Update this would be something like AI.Update() as both the Input and AI handle the object's movement
    Phys.Update();
    Anim.Update();
}

And finally here's an idea of what the Input.Update() might look like

Input::Update()
{
    If (keyPressed::A)
          //Logic to move the player left
    if (keyPressed:D)
          //Logic to move the player right
    if (keyPressed::K)
          //Logic to attack for example
     ...
     ...
     and so on...
}

So the grand idea behind updating like that is: movement --> physics --> animation

First the object asks to move, and if the physics allow it (doesn't collide for example) then it's moved and some animation plays, I hope that makes any sense in terms of programming.

Sorry about the lengthy post, and I'd like to thank you Serapth for taking the time to write those in-depth answers.

I'm finally starting to grasp what you mean, and the problems I'm facing and going to face with my current design (solve one problem and two more appear). I managed to make

it so that the subclasses (physics, animation etc.) can modify the owner class, but only if it's a GameObject, so that means no physics for player and enemies, trying to fix that issue just kept creating more.

I did in fact try to create another player, but it wouldn't get drawn, and with my current design I suppose I would've controlled both players at the same time with the same keys.

I presume a step in the right direction would be creating a single class that manages whatever is in its area of responsibility, and then make that affect the objects?

But yeah, I pretty much wrote myself into a corner. Maybe I should be patient and shelf this project for now and finish reading up on OOP and then maybe read about basic game design. Thanks for your advice, you probably saved me a lot of time.