The "concept" of an oo game

In most or all object oriented games, each class relies on not just its own but 开发者_StackOverflow中文版parent classes. How is this class connection implemented in C++? Do you just add a pointer for the parent class you need or is there a better way?

For example a football game, when the person class clicks it ask the scene class if he is kicking any balls, and if he is then move it. I hope this is understandable and not too abstract.

---

I don't think passing along the parent in a constructor is a good idea. Instead, you should be using a class that maintains a list of all game elements and facilities interactions between them; for instance, the Game class illustrated below would check for collisions between any two players and if it's detected tell each of them that they were hit and by who.

I'm not sure if this will benefit you at all, but I typed it up for my initial response so I might as well submit. Note that all of this is still relevant if you're talking about a text-only game, just ignore the allusions to graphics in that case. Game design is based around a continuous game loop, and can be thought of very simply as:

while(true)
    for each tick:
        react to user input
        update player, enemies, objects, etc.
end while

Where "tick" is every iteration of the game clock, however you choose to implement it--based on the fps, each second, whatever. In your example, the user clicks the football, the game sees the click and tells the football to move. To do this very simply, maintain a list all of all of the game elements within a class that maintains the state. To illustrate, here are is a very basic way you could implement this:

class Game {
    vector<GameElement> elements;
Football football;
Player currentPlayer;

Game() {
    this.football = new Football();
}

    void update() {
        for e in elements:
            e.update();

        // Once every element has been updated for the current tick, redraw them on the screen  
        screen.redraw();
    }
    void addElement(GameElement e) {
        elements.add(e);
    }
}

class GameElement {
    int posx, posy;     // screen coordinates
    void paint() {};    // method to draw this element to the screen
    virtual void update();
}

class Football: public GameElement {
    bool kicked;
    int anglex, angley;
    double velocity;

    void update() {
        if(kicked){
            // update position, angle, velocity; slow it down, check for bounce, whatever
            posx = new x position;
            posy = new y position;
        if(velocity == 0)
            kicked = false;     
        }
        paint();    // call the paint method after the new position has been found
    }
}

Assume you have another class that inherits from GameElement, Player, with a method kick(football) that sets the passed football into motion--i.e., sets kicked=True. So to initialize the game, you'd set it up with something like:

Game game = Game();
game.add(new Football());
game.add(new Player());
while(true) {
if(user_input==X)
    game.currentPlayer.kick(football);
    game.update();
    sleep(1);
}

This could be changed to maintain, for example, layers instead of the entire game, then a higher level class could call update of each layer in order, allowing things to be painted over each other and children to only interact with siblings. There are a lot of possibilities.

---

Ran into similar questions working on a poker game: Here's the way I did it:

In your example, add a scene * the_scene to the constructor of person. Then, when person is initialized pass it a pointer to scene. Since you said parent and child, if the parent Is scene then it would just use "this" and it would send the address of the parent.

Then again, it seems like that's how you were going to do it anyway. One more thing, if you need person to interact with more than one class that is not directly inside it you can make some kind of container class that would store the pointers to all of them and just pass person that one to avoid having a constructor with too many parameters.