begun monster vicinity checking

[l2e.git] / src / map / MapState.cpp

diff --git a/src/map/MapState.cpp b/src/map/MapState.cpp
index e215f40f872a6b2d36aaca059761e0731c1e2d70..62e480267ca092f31a178f2ffe2274f8792fc229 100644 (file)
--- a/src/map/MapState.cpp
+++ b/src/map/MapState.cpp
@@ -94,22 +94,7 @@ void MapState::OnTileLock() {
        // TODO: halt all activity if lock caused a state/map transition
 
        if (nextDirection >= 0) {
-               const Tile &tile(map->TileAt(controlled->Position()));
-               bool blocked(false);
-               switch (nextDirection) {
-                       case Entity::ORIENTATION_NORTH:
-                               blocked = tile.BlocksNorth();
-                               break;
-                       case Entity::ORIENTATION_EAST:
-                               blocked = tile.BlocksEast();
-                               break;
-                       case Entity::ORIENTATION_SOUTH:
-                               blocked = tile.BlocksSouth();
-                               break;
-                       case Entity::ORIENTATION_WEST:
-                               blocked = tile.BlocksWest();
-                               break;
-               }
+               bool blocked(CheckBlocking());
                if (afterLock) {
                        OnMove(!blocked);
                        afterLock = false;
@@ -139,22 +124,100 @@ void MapState::OnTileLock() {
        lastLock = nowLock;
 }
 
+bool MapState::CheckBlocking() const {
+       const Tile &tile(map->TileAt(controlled->Position()));
+       Vector<int> nextPosition;
+       switch (nextDirection) {
+               case Entity::ORIENTATION_NORTH:
+                       if (tile.BlocksNorth()) {
+                               return true;
+                       } else {
+                               nextPosition = Vector<int>(
+                                               controlled->Position().X(),
+                                               controlled->Position().Y() - map->Tileset()->Height());
+                       }
+                       break;
+               case Entity::ORIENTATION_EAST:
+                       if (tile.BlocksEast()) {
+                               return true;
+                       } else {
+                               nextPosition = Vector<int>(
+                                               controlled->Position().X() + map->Tileset()->Width(),
+                                               controlled->Position().Y());
+                       }
+                       break;
+               case Entity::ORIENTATION_SOUTH:
+                       if (tile.BlocksSouth()) {
+                               return true;
+                       } else {
+                               nextPosition = Vector<int>(
+                                               controlled->Position().X(),
+                                               controlled->Position().Y() + map->Tileset()->Height());
+                       }
+                       break;
+               case Entity::ORIENTATION_WEST:
+                       if (tile.BlocksWest()) {
+                               return true;
+                       } else {
+                               nextPosition = Vector<int>(
+                                               controlled->Position().X() - map->Tileset()->Width(),
+                                               controlled->Position().Y());
+                       }
+                       break;
+               default:
+                       return false;
+       }
+       Vector<int> nextTileCoords(map->TileCoordinates(nextPosition));
+       for (std::vector<Entity *>::const_iterator i(entities.begin()), end(entities.end()); i != end; ++i) {
+               const Entity &e(**i);
+               if (map->TileCoordinates(e.Position()) == nextTileCoords && e.Blocking()) {
+                       return true;
+               }
+       }
+       return false;
+}
+
 void MapState::OnGridLock() {
        LockEntities();
-       Trigger *trigger(map->TriggerAt(Vector<int>(controlled->Position())));
-       if (trigger) {
-               // TODO: run trigger
-       }
-       // TODO: check for adjacent monsters
-       // TODO: force all entities into their grid positions?
+       CheckMonster();
+       CheckTrigger();
 }
 
 void MapState::LockEntities() {
        for (std::vector<Entity *>::iterator i(entities.begin()), end(entities.end()); i != end; ++i) {
+               if (*i == controlled) {
+                       // don't lock player
+                       continue;
+               }
                (*i)->Position().Lock(map->Tileset()->Size());
        }
 }
 
+void MapState::CheckMonster() {
+       Vector<int> coords(map->TileCoordinates(controlled->Position()));
+       Vector<int> neighbor[4];
+       neighbor[0] = Vector<int>(coords.X() - 1, coords.Y()); // W
+       neighbor[1] = Vector<int>(coords.X(), coords.Y() + 1); // S
+       neighbor[2] = Vector<int>(coords.X() + 1, coords.Y()); // E
+       neighbor[3] = Vector<int>(coords.X(), coords.Y() - 1); // N
+
+       for (int i(0); i < 4; ++i) {
+               for (std::vector<Entity *>::iterator e(entities.begin()), end(entities.end()); e != end; ++e) {
+                       if ((*e)->Hostile() && map->TileCoordinates((*e)->Position()) == neighbor[i]) {
+                               // remove entity, push battle state and transition and halt all other activity
+                       }
+               }
+       }
+}
+
+void MapState::CheckTrigger() {
+       Trigger *trigger(map->TriggerAt(Vector<int>(controlled->Position())));
+       if (trigger) {
+               // TODO: run trigger
+       }
+
+}
+
 void MapState::OnMove(bool realMove) {
        // TODO: evaluate monster movements
        if (realMove) {