I don't have any specific advice but try to reduce the amount of things each class does. Having a class that starts things up, initialises the window and runs the main loop is a good idea, it can then dispatch events to where ever they are needed. Below that you can have a Game class that is the actual game. The idea is to reduce the amount of work each class does, the Game class isn't also responsible for window management and so on.

The less each class does the less issues you will get with your headers too. You can use forward declaration in your headers such that you don't have to include things that are not needed (As you said you have tried). E.g. the Game has a Player object you can do this in the header:

class Player;

class Game
{
   Player* m_Player;
};

That way you don't need to have 'include "Player.h" at the top of Game.h and thus anything that includes Game.h no longer also includes Player.h. That can help a lot but it also means you have to create things with new. You'll have to be a bit mroe specific when you say your forward declaration didn't work, this won't work for example:

class Player

class Game
{
   Player m_Player; // note this is an object of type Player rather than a pointer
};

So smaller objects and forward declaration. If you think part of one of your objects could be neatly wrapped up in a small group then it is a good candidate to be a separate object.

-Sprite class
-Player class(inherited from sprite)

In addition to Nanoha's suggestions, something here seems wrong.

Use inheritance if the Player IS A Sprite. This seems unlikely to be the case.

You might want to look into composition, which is used when the Player HAS A Sprite.

Hi.

You're question is too big (for me) to cover with just 1 right answer.

So here's my share:

- when you have headers that you want to include in several places, 'ifdef' them

(so they're just compiled once)

#ifndef CD3DCAM_H
#define CD3DCAM_H

(top of your headers)

- in general a class should have 1 purpose only (like mentioned above)

- when you want to make a 'game engine', think of modules, for example:

-- audio

-- IO

-- rendering

-- scenes/ levels

-- objects

-- meshes ( --- submeshes etc.)

You could use a namespace for each 'module'

- when you have headers that you want to include in several places, 'ifdef' them
(so they're just compiled once)
#ifndef CD3DCAM_H
#define CD3DCAM_H
(top of your headers)

Just to clarify that a bit, At the top you could/should have:

#ifndef CD3DCAM_H // the name is chosen based on your header name

#define CD3DCAM_H

Then you would have all the code and finally at the bottom you would have

#endif

As Cozzie points out that will stop the headers being included more than once. You might have:

#pragma once

at the top of your headers instead which also solves the same issue. I do believe using both is ok but you should use at least one of the options.

Thanks so much everyone! I am indeed using #pragma once by the way. I noticed that when I'm creating a method which takes a reference of an object, I need a forward declaration for that object.

But why use a forward declaration and create a pointer for an object?

like here:

class Player;

class Game
{
Player* m_Player;
};

rather than:

#include "Player.h"

class Game
{
Player m_Player;
};

is this done just to avoid header file problems?

Yes, that method is used to reduce the amount of dependencies on headers as TheCandadianVendingMachine describes it helps with recompile times and you can use it when you need an array of unknown size. It does have drawbacks, such as having to create the objects using new and remembering to delete them, having to implement non-trivial copy/assign constructors/operator.

Another method that might help you (and is good practice in general) is to use namespaces.

Game.h

#pragma once

namespace my_game
{
   class Player;

   class Game
   {
   public:
      Game();
      ~Game();
      // You would also need copy/assign constructors/operators since m_Player 
      // is created with new or just mark them deleted:
      Game(const Game&) = delete;
      Game& operator=(const Game&) = delete;
   private:
      Player* m_Player;
   };
}

Game.cpp

#include "Game.h"
#include "Player.h"

namespace my_game
{
   Game::Game()
   {
      m_Player = new Player;
   }

   Game::~Game()
   {
      delete m_Player;
   }
}

It doesn't reduce how headers are dragged in but it can help with some naming conflicts.