initialize lastLock to an improbable position

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

diff --git a/src/map/MapState.cpp b/src/map/MapState.cpp
index 773190e88952b604511fb4a249f94d751035c4a2..8dab40e9bba9bde45dcf9a154bacf34f6a1454c4 100644 (file)
--- a/src/map/MapState.cpp
+++ b/src/map/MapState.cpp
@@ -34,12 +34,14 @@ MapState::MapState(GameConfig *g, Map *map)
 , ctrl(0)
 , map(map)
 , controlled(0)
-, tempTarget(20, 20)
-, camera(100, 100, &tempTarget)
+, pushed(0)
+, lastLock(-1, -1)
+, camera(100, 100, 0)
 , walkingSpeed(64)
 , nextDirection(-1)
 , afterLock(false)
 , skipLock(false)
+, pushing(false)
 , debug(false) {
 
 }
@@ -83,6 +85,8 @@ void MapState::HandleEvents(const Input &input) {
                nextDirection = -1;
        }
 
+       pushing = input.IsDown(Input::ACTION_A);
+
        if (input.JustPressed(Input::DEBUG_1)) {
                debug = !debug;
        }
@@ -116,83 +120,136 @@ void MapState::OnTileLock() {
        }
 
        if (nextDirection >= 0) {
-               bool blocked(CheckBlocking());
                if (afterLock) {
+                       bool blocked(CheckBlocking());
                        OnMove(!blocked);
                        afterLock = false;
-               }
-               controlled->SetOrientation(Entity::Orientation(nextDirection));
-               if (!blocked) {
-                       controlled->SetSpeed(walkingSpeed);
-                       moveTimer.Clear();
-               } else {
-                       controlled->SetSpeed(0.0f);
-                       StopFollowers(*controlled);
-                       if (!moveTimer.Running()) {
-                               int tileSize((controlled->GetOrientation() % 2) ? map->Tileset()->Width() : map->Tileset()->Height());
-                               moveTimer = PhysicsTimers().StartInterval(tileSize/walkingSpeed);
+                       controlled->SetOrientation(Entity::Orientation(nextDirection));
+                       if (!blocked) {
+                               controlled->SetSpeed(walkingSpeed);
+                               moveTimer.Clear();
+                               if (pushed) {
+                                       pushed->SetOrientation(Entity::Orientation(nextDirection));
+                                       pushed->SetSpeed(walkingSpeed);
+                                       controlled->SetPushing();
+                               } else {
+                                       controlled->SetHandsFree();
+                               }
+                       } else {
+                               controlled->SetSpeed(0.0f);
+                               StopFollowers(*controlled);
+                               if (!moveTimer.Running()) {
+                                       int tileSize((controlled->GetOrientation() % 2) ? map->Tileset()->Width() : map->Tileset()->Height());
+                                       moveTimer = PhysicsTimers().StartInterval(tileSize/walkingSpeed);
+                               }
+                               pushed = 0;
+                       }
+                       if (!controlled->AnimationRunning()) {
+                               controlled->StartAnimation(*this);
                        }
-               }
-               if (!controlled->AnimationRunning()) {
-                       controlled->StartAnimation(*this);
                }
        } else {
                controlled->SetSpeed(0.0f);
                StopFollowers(*controlled);
                controlled->StopAnimation();
                moveTimer.Clear();
+               if (pushed) {
+                       pushed->SetSpeed(0.0f);
+                       pushed = 0;
+               }
        }
 
        lastLock = nowLock;
 }
 
-bool MapState::CheckBlocking() const {
-       const Tile *tile(map->TileAt(controlled->Position()));
-       if (!tile) {
-               return false;
+bool MapState::CheckBlocking() {
+       if (pushed) {
+               pushed->SetSpeed(0.0f);
+               pushed = 0;
        }
-       Vector<int> nextPosition;
+       const Tile *tile(map->TileAt(controlled->Position()));
+       Vector<int> direction;
        switch (nextDirection) {
                case Entity::ORIENTATION_NORTH:
-                       if (tile->BlocksNorth()) {
+                       if (tile && tile->BlocksNorth()) {
+                               return true;
+                       } else {
+                               direction = Vector<int>(0, -map->Tileset()->Height());
+                       }
+                       break;
+               case Entity::ORIENTATION_EAST:
+                       if (tile && tile->BlocksEast()) {
+                               return true;
+                       } else {
+                               direction = Vector<int>(map->Tileset()->Width(), 0);
+                       }
+                       break;
+               case Entity::ORIENTATION_SOUTH:
+                       if (tile && tile->BlocksSouth()) {
+                               return true;
+                       } else {
+                               direction = Vector<int>(0, map->Tileset()->Height());
+                       }
+                       break;
+               case Entity::ORIENTATION_WEST:
+                       if (tile && tile->BlocksWest()) {
+                               return true;
+                       } else {
+                               direction = Vector<int>(-map->Tileset()->Width(), 0);
+                       }
+                       break;
+               default:
+                       return false;
+       }
+       Vector<int> nextTilePosition(direction + controlled->Position());
+       Vector<int> nextTileCoords(map->TileCoordinates(nextTilePosition));
+       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) continue;
+               if (!e.Blocking()) continue;
+               if (!pushing || !e.Pushable()) return true;
+               if (CheckBlocking(nextTilePosition, Entity::Orientation(nextDirection))) return true;
+               pushed = *i;
+       }
+       return false;
+}
+
+bool MapState::CheckBlocking(const Vector<int> &position, Entity::Orientation direction) const {
+       const Tile *tile(map->TileAt(position));
+       Vector<int> directionVector;
+       switch (direction) {
+               case Entity::ORIENTATION_NORTH:
+                       if (tile && tile->BlocksNorth()) {
                                return true;
                        } else {
-                               nextPosition = Vector<int>(
-                                               controlled->Position().X(),
-                                               controlled->Position().Y() - map->Tileset()->Height());
+                               directionVector = Vector<int>(0, -map->Tileset()->Height());
                        }
                        break;
                case Entity::ORIENTATION_EAST:
-                       if (tile->BlocksEast()) {
+                       if (tile && tile->BlocksEast()) {
                                return true;
                        } else {
-                               nextPosition = Vector<int>(
-                                               controlled->Position().X() + map->Tileset()->Width(),
-                                               controlled->Position().Y());
+                               directionVector = Vector<int>(map->Tileset()->Width(), 0);
                        }
                        break;
                case Entity::ORIENTATION_SOUTH:
-                       if (tile->BlocksSouth()) {
+                       if (tile && tile->BlocksSouth()) {
                                return true;
                        } else {
-                               nextPosition = Vector<int>(
-                                               controlled->Position().X(),
-                                               controlled->Position().Y() + map->Tileset()->Height());
+                               directionVector = Vector<int>(0, map->Tileset()->Height());
                        }
                        break;
                case Entity::ORIENTATION_WEST:
-                       if (tile->BlocksWest()) {
+                       if (tile && tile->BlocksWest()) {
                                return true;
                        } else {
-                               nextPosition = Vector<int>(
-                                               controlled->Position().X() - map->Tileset()->Width(),
-                                               controlled->Position().Y());
+                               directionVector = Vector<int>(-map->Tileset()->Width(), 0);
                        }
                        break;
                default:
                        return false;
        }
-       Vector<int> nextTileCoords(map->TileCoordinates(nextPosition));
+       Vector<int> nextTileCoords(map->TileCoordinates(directionVector + position));
        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()) {
@@ -347,7 +404,9 @@ void MapState::UnloadMap() {
 
 void MapState::LoadMap(Map *m) {
        map = m;
-       entities.insert(entities.end(), m->EntitiesBegin(), m->EntitiesEnd());
+       for (Entity *e(m->EntitiesBegin()), *end(m->EntitiesEnd()); e != end; ++e) {
+               entities.push_back(e);
+       }
        for (Entity *e(controlled); e; e = e->Follower()) {
                entities.push_back(e);
        }