don't lock player character onto its tile

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

diff --git a/src/map/MapState.cpp b/src/map/MapState.cpp
index ed776482e3763084308af422cfe31766787cca1b..26e20da4948bec91eb126e18fb3e585ae46e923b 100644 (file)
--- a/src/map/MapState.cpp
+++ b/src/map/MapState.cpp
@@ -8,19 +8,26 @@
 #include "MapState.h"
 
 #include "Map.h"
+#include "Tile.h"
 #include "../app/Application.h"
 #include "../app/Input.h"
 
+#include <algorithm>
+
 using app::Application;
 using app::Input;
 using geometry::Vector;
 
 namespace map {
 
-MapState::MapState(const Map *map)
+MapState::MapState(Map *map)
 : map(map)
+, controlled(0)
 , tempTarget(20, 20)
-, camera(100, 100, &tempTarget) {
+, camera(100, 100, &tempTarget)
+, walkingSpeed(64)
+, nextDirection(-1)
+, afterLock(false) {
 
 }
 
@@ -47,16 +54,175 @@ void MapState::Resize(int width, int height) {
 
 
 void MapState::HandleEvents(const Input &input) {
-
+       if (!controlled) return;
+
+       if (input.IsDown(Input::PAD_UP)) {
+               nextDirection = Entity::ORIENTATION_NORTH;
+       } else if (input.IsDown(Input::PAD_RIGHT)) {
+               nextDirection = Entity::ORIENTATION_EAST;
+       } else if (input.IsDown(Input::PAD_DOWN)) {
+               nextDirection = Entity::ORIENTATION_SOUTH;
+       } else if (input.IsDown(Input::PAD_LEFT)) {
+               nextDirection = Entity::ORIENTATION_WEST;
+       } else {
+               nextDirection = -1;
+       }
 }
 
 void MapState::UpdateWorld(float deltaT) {
+       if (controlled && controlled->TileLock(map->Tileset()->Size())) {
+               OnTileLock();
+       }
+       for (std::vector<Entity *>::iterator i(entities.begin()), end(entities.end()); i != end; ++i) {
+               (*i)->Update(deltaT);
+       }
+}
+
+void MapState::OnTileLock() {
+       if (moveTimer.Running() && !moveTimer.JustHit()) return;
+
+       Vector<int> nowLock(controlled->Position());
+       if (nowLock != lastLock) {
+               OnGridLock();
+               afterLock = true;
+               moveTimer.Clear();
+       } else if (moveTimer.JustHit()) {
+               OnGridLock();
+               afterLock = true;
+       }
+
+       // 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;
+               }
+               if (afterLock) {
+                       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);
+                       }
+               }
+               if (!controlled->AnimationRunning()) {
+                       controlled->StartAnimation(*this);
+               }
+       } else {
+               controlled->SetSpeed(0.0f);
+               StopFollowers(*controlled);
+               controlled->StopAnimation();
+               moveTimer.Clear();
+       }
+
+       lastLock = nowLock;
+}
 
+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?
 }
 
+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::OnMove(bool realMove) {
+       // TODO: evaluate monster movements
+       if (realMove) {
+               UpdateFollower(*controlled);
+       } else {
+               StopFollowers(*controlled);
+       }
+}
+
+void MapState::UpdateFollower(Entity &e) {
+       if (!e.Follower()) return;
+
+       Entity &f(*e.Follower());
+       UpdateFollower(f);
+
+       Vector<int> coords(map->TileCoordinates(e.Position()));
+       Vector<int> fCoords(map->TileCoordinates(f.Position()));
+       Vector<int> direction(coords - fCoords);
+
+       if (direction.Y() < 0) {
+               f.SetOrientation(Entity::ORIENTATION_NORTH);
+               f.SetSpeed(walkingSpeed);
+               f.StartAnimation(*this);
+       } else if (direction.X() > 0) {
+               f.SetOrientation(Entity::ORIENTATION_EAST);
+               f.SetSpeed(walkingSpeed);
+               f.StartAnimation(*this);
+       } else if (direction.Y() > 0) {
+               f.SetOrientation(Entity::ORIENTATION_SOUTH);
+               f.SetSpeed(walkingSpeed);
+               f.StartAnimation(*this);
+       } else if (direction.X() < 0) {
+               f.SetOrientation(Entity::ORIENTATION_WEST);
+               f.SetSpeed(walkingSpeed);
+               f.StartAnimation(*this);
+       } else {
+               f.SetSpeed(0.0f);
+               f.StopAnimation();
+       }
+}
+
+void MapState::StopFollowers(Entity &e) {
+       for (Entity *f(e.Follower()); f; f = f->Follower()) {
+               f->SetSpeed(0.0f);
+               f->StopAnimation();
+       }
+}
+
+
 void MapState::Render(SDL_Surface *screen) {
+       SDL_FillRect(screen, 0, SDL_MapRGB(screen->format, 0, 0, 0));
+
        Vector<int> offset(camera.CalculateOffset());
        map->Render(screen, offset);
+
+       std::sort(entities.begin(), entities.end(), ZCompare);
+       for (std::vector<Entity *>::iterator i(entities.begin()), end(entities.end()); i != end; ++i) {
+               (*i)->Render(screen, offset);
+       }
+}
+
+
+bool MapState::ZCompare(const Entity *lhs, const Entity *rhs) {
+       return lhs->Position().Y() < rhs->Position().Y();
 }
 
 }