How can I avoid coupling between units and their environment?

Question

Currently in the process of making a game like Dwarf Fortress, so without graphics. I'm mostly thinking about how I want to implement everything. While writing code I keep stumbling on general game implementation problems that are really annoying me. Assume this:

We have a Map class which stores Chunk classes which stores Tile classes which stores Players and Enemys currently on this tile.

class Map {
    public:
        std::vector<std::vector<Chunk>> chunks;
};

class Chunk {
    public:
        std::vector<std::vector<Tile>> tiles;
        std::vector<Player*> player_need_update;
        std::vector<Enemy*> needs_update;
};

class Tile {
    public:
        std::vector<Player*> players;
        std::vector<Enemy*> enemies;
};

Now let's say I want to move() a player to a different Tile. For this I created a needs_update vector storing entities that need to be updated on the game Map. Every game tick we loop all chunks and loop all entities needing an update.

I think (thought) this is a logical way of doing this because we can have a tile that is independent of a chunk that is independent of a map. Same for entities. So let's say we want to move an Entity:

void Entity::move(uint16_t move_x, uint16_t move_y) {
    x += move_x;
    y += move_y;
    
    changed() // Notify chunk that something changed about us
}

This is already where it is going wrong. To be able to notify the chunk we have moved, we need to know ourselves in which chunk we are Chunk *in_chunk; in class Entity. And this breaks the structure I wanted to achieve (independence across classes).

Another example, suppose we want to attack an Entity on a different Tile. We would need to know there is an entity in the first place, but we would also need to know things about the enemy to then decide whether to attack it or not.

Player::attack(Enemy &enemy /* ?? */) {
    // Attack
}

I think it is wrong to move a player by calling a function in Map:

void Map::movePlayer(Player &player) {
    // Do stuff to move player
}

So, how do you implement basic game structures like this, keeping things logically structured but while still being able to ie. move a player across the map?

Answer 1

The target implementation of your Map and entities is very much like a graph, or, more specifically, a tree:

Since the goal is to minimize references to parent nodes, we will call update methods from parents, as well as have parents pass data to those children that is necessary for them to update.

Since entities need to be able to move throughout the tree, it's inevitable that we will need some sort of function in the Map and Chunk to be able to move entities to different nodes. However, we can separate updating the graph from updating the state of the entities, which will keep them from storing references to one another.

Updating the Map Graph

Since your Entity::move method adjusts fields for x and y, it seems that you already locally store the coordinates of your entities. Thus, you have enough information to know when to delete references to entities in your Chunks and Tiles; specifically, when their coordinates are no longer within the bounds of that Chunk or Tile.

For example, in your Tile class (I'm doing this in Javaish-pseudocode since I'm clueless with C++ and don't want to cause confusion):

for(Player player in players) {
    if(player.coordinates != this.coordinates) {
        player.needsMove = true;
        /*Remove reference to player from vector*/;
    }
}

Then, in your Chunk class:

for(Player player in player_need_update) {
    if(player.needsMove) {
        if(inThisChunk(player.coordinates)) {
            /*Add a reference to this player in the appropriate Tile in this Chunk*/;
            player.needsMove = false;
        }
    }
}

And you'd have to do the same in your Map class if entities can move between Chunks.

Detection Among Entities

A similar approach could help the entities detect one another. For example, take the case of Players attacking Enemies. If a Player can only attack Enemies within the same Chunk, then we could do something like this in the Chunk class:

for(Player player in player_need_update) {
    for(Enemy enemy in enemies) {
        if(player.shouldAttack(enemy)) {
            player.attack(enemy);
        }
    }
}

From there, calls to Player::attack() can be passed references to enemies without storing them for long-term use.