GameObject store its own location in a tile based game? - dictionary

Question

Making a tile based game with a MVC design pattern. In my map model I have a 2D array of all of the game objects, so that deals with location. But I do have cases when an object needs to know its own location, such as range for a spell. Is it a good idea for the object to also store its own location? I see issues with both sides.
Object does not know its own location. Location data only stored in map. If I have a location I can find an object immediately. But to go from object to location I have to iterate through an array.
Object knows it own location. Location data stored in Map and Object. If I have an active object I can just pull the location right out of the object. But this may lead to inconsistency between the map array and the object's location. I am not sure to make sure one is not updated without changing the other. I could just have each controller (object and map) have a function for moving objects, and when one is called it looks to see if the other's model is consistent and updates it. However, this seems extremely inelegant.

Answer 1

I'd advise you to store the location in the GameObject and make sure the locations are consistent by using private fields and a single function to modify your locations. The location could be a private member of the GameObject, and the 2D array should be a private member of the Map-class. Then you define a function in the Map-class which allows you to move the object. This function should update the array as well as the location stored in the object. How you grant the Map class access to the GameObject's location depends on the programming language. In Java you could implement a package-private function (this is the default access level) and define the Map and GameObject in the same class, in C# you could define an internal function and define the Map and GameObject in the same assembly, in C++ you could make the Map.move function a friend of the GameObject, granting it access to the protected and private members of the GameObject.
The only downside of this approach, is that you could still accidentally modify the GameObject's location within the GameObject itself, without updating the array. If you want to prevent this, you could store the location of each object in a map/Dictionary in the Map-class. In C++ this would look roughly like this:
#include<map>
class GameObject {}; //don't store the location here
struct Location {
int x,y;
};
class Map {
private:
//the 2D array containing pointers to the GameObjects
GameObject* array[WIDTH][HEIGHT];
//a map containing the locations of all the GameObjects, indexed by a pointer to them.
std::map<GameObject*,Location> locations;
public:
//move an object from a given location to another
void move( int fromX, int fromY, int toX, int toY ) {
GameObject* obj = array[fromX][fromY;
array[toX][toY] = obj
array[fromX][fromY] = 0;
locations[obj].x = toX;
locations[obj].y = toY;
}
//move a given object to a location
void move( GameObject* obj, int toX, int toY ) {
Location loc = locations[obj];
move( loc.x, loc.y, toX, toY );
}
//get the location of a given object
Location getLocation( GameObject* obj ) const {
return locations[obj];
}
};