src/map/MapState.cpp

   1 /*
   2  * MapState.cpp
   3  *
   4  *  Created on: Sep 29, 2012
   5  *      Author: holy
   6  */
   7
   8 #include "MapState.h"
   9
  10 #include "Map.h"
  11 #include "Tile.h"
  12 #include "TransitionState.h"
  13 #include "Trigger.h"
  14 #include "../app/Application.h"
  15 #include "../app/Input.h"
  16 #include "../battle/BattleState.h"
  17 #include "../common/GameConfig.h"
  18 #include "../common/GameState.h"
  19 #include "../graphics/ColorFade.h"
  20
  21 #include <algorithm>
  22
  23 using app::Application;
  24 using app::Input;
  25 using battle::BattleState;
  26 using common::GameConfig;
  27 using geometry::Vector;
  28 using graphics::ColorFade;
  29
  30 namespace map {
  31
  32 MapState::MapState(GameConfig *g, Map *map)
  33 : game(g)
  34 , ctrl(0)
  35 , map(map)
  36 , controlled(0)
  37 , pushed(0)
  38 , camera(100, 100, 0)
  39 , walkingSpeed(64)
  40 , nextDirection(-1)
  41 , afterLock(false)
  42 , skipLock(false)
  43 , pushing(false)
  44 , debug(false) {
  45
  46 }
  47
  48
  49 void MapState::EnterState(Application &c, SDL_Surface *screen) {
  50         ctrl = &c;
  51         camera.Resize(screen->w, screen->h);
  52         LoadMap(map);
  53 }
  54
  55 void MapState::ExitState(Application &ctrl, SDL_Surface *screen) {
  56
  57 }
  58
  59 void MapState::ResumeState(Application &ctrl, SDL_Surface *screen) {
  60         camera.Resize(screen->w, screen->h);
  61 }
  62
  63 void MapState::PauseState(Application &ctrl, SDL_Surface *screen) {
  64
  65 }
  66
  67 void MapState::Resize(int width, int height) {
  68         camera.Resize(width, height);
  69 }
  70
  71
  72 void MapState::HandleEvents(const Input &input) {
  73         if (!controlled) return;
  74
  75         if (input.IsDown(Input::PAD_UP)) {
  76                 nextDirection = Entity::ORIENTATION_NORTH;
  77         } else if (input.IsDown(Input::PAD_RIGHT)) {
  78                 nextDirection = Entity::ORIENTATION_EAST;
  79         } else if (input.IsDown(Input::PAD_DOWN)) {
  80                 nextDirection = Entity::ORIENTATION_SOUTH;
  81         } else if (input.IsDown(Input::PAD_LEFT)) {
  82                 nextDirection = Entity::ORIENTATION_WEST;
  83         } else {
  84                 nextDirection = -1;
  85         }
  86
  87         pushing = input.IsDown(Input::ACTION_A);
  88
  89         if (input.JustPressed(Input::DEBUG_1)) {
  90                 debug = !debug;
  91         }
  92 }
  93
  94 void MapState::UpdateWorld(float deltaT) {
  95         if (controlled && controlled->TileLock(map->Tileset()->Size())) {
  96                 OnTileLock();
  97         }
  98         for (std::vector<Entity *>::iterator i(entities.begin()), end(entities.end()); i != end; ++i) {
  99                 (*i)->Update(deltaT);
 100         }
 101 }
 102
 103 void MapState::OnTileLock() {
 104         if (moveTimer.Running() && !moveTimer.JustHit()) return;
 105
 106         Vector<int> nowLock(controlled->Position());
 107         bool event(false);
 108         if (nowLock != lastLock) {
 109                 event = OnGridLock();
 110                 afterLock = true;
 111                 moveTimer.Clear();
 112         } else if (moveTimer.JustHit()) {
 113                 event = OnGridLock();
 114                 afterLock = true;
 115         }
 116
 117         if (event) {
 118                 return;
 119         }
 120
 121         if (nextDirection >= 0) {
 122                 if (afterLock) {
 123                         bool blocked(CheckBlocking());
 124                         OnMove(!blocked);
 125                         afterLock = false;
 126                         controlled->SetOrientation(Entity::Orientation(nextDirection));
 127                         if (!blocked) {
 128                                 controlled->SetSpeed(walkingSpeed);
 129                                 moveTimer.Clear();
 130                                 if (pushed) {
 131                                         pushed->SetOrientation(Entity::Orientation(nextDirection));
 132                                         pushed->SetSpeed(walkingSpeed);
 133                                         controlled->SetPushing();
 134                                 } else {
 135                                         controlled->SetHandsFree();
 136                                 }
 137                         } else {
 138                                 controlled->SetSpeed(0.0f);
 139                                 StopFollowers(*controlled);
 140                                 if (!moveTimer.Running()) {
 141                                         int tileSize((controlled->GetOrientation() % 2) ? map->Tileset()->Width() : map->Tileset()->Height());
 142                                         moveTimer = PhysicsTimers().StartInterval(tileSize/walkingSpeed);
 143                                 }
 144                                 pushed = 0;
 145                         }
 146                         if (!controlled->AnimationRunning()) {
 147                                 controlled->StartAnimation(*this);
 148                         }
 149                 }
 150         } else {
 151                 controlled->SetSpeed(0.0f);
 152                 StopFollowers(*controlled);
 153                 controlled->StopAnimation();
 154                 moveTimer.Clear();
 155                 if (pushed) {
 156                         pushed->SetSpeed(0.0f);
 157                         pushed = 0;
 158                 }
 159         }
 160
 161         lastLock = nowLock;
 162 }
 163
 164 bool MapState::CheckBlocking() {
 165         if (pushed) {
 166                 pushed->SetSpeed(0.0f);
 167                 pushed = 0;
 168         }
 169         const Tile *tile(map->TileAt(controlled->Position()));
 170         Vector<int> direction;
 171         switch (nextDirection) {
 172                 case Entity::ORIENTATION_NORTH:
 173                         if (tile && tile->BlocksNorth()) {
 174                                 return true;
 175                         } else {
 176                                 direction = Vector<int>(0, -map->Tileset()->Height());
 177                         }
 178                         break;
 179                 case Entity::ORIENTATION_EAST:
 180                         if (tile && tile->BlocksEast()) {
 181                                 return true;
 182                         } else {
 183                                 direction = Vector<int>(map->Tileset()->Width(), 0);
 184                         }
 185                         break;
 186                 case Entity::ORIENTATION_SOUTH:
 187                         if (tile && tile->BlocksSouth()) {
 188                                 return true;
 189                         } else {
 190                                 direction = Vector<int>(0, map->Tileset()->Height());
 191                         }
 192                         break;
 193                 case Entity::ORIENTATION_WEST:
 194                         if (tile && tile->BlocksWest()) {
 195                                 return true;
 196                         } else {
 197                                 direction = Vector<int>(-map->Tileset()->Width(), 0);
 198                         }
 199                         break;
 200                 default:
 201                         return false;
 202         }
 203         Vector<int> nextTilePosition(direction + controlled->Position());
 204         Vector<int> nextTileCoords(map->TileCoordinates(nextTilePosition));
 205         for (std::vector<Entity *>::const_iterator i(entities.begin()), end(entities.end()); i != end; ++i) {
 206                 const Entity &e(**i);
 207                 if (map->TileCoordinates(e.Position()) != nextTileCoords) continue;
 208                 if (!e.Blocking()) continue;
 209                 if (!pushing || !e.Pushable()) return true;
 210                 if (CheckBlocking(nextTilePosition, Entity::Orientation(nextDirection))) return true;
 211                 pushed = *i;
 212         }
 213         return false;
 214 }
 215
 216 bool MapState::CheckBlocking(const Vector<int> &position, Entity::Orientation direction) const {
 217         const Tile *tile(map->TileAt(position));
 218         Vector<int> directionVector;
 219         switch (direction) {
 220                 case Entity::ORIENTATION_NORTH:
 221                         if (tile && tile->BlocksNorth()) {
 222                                 return true;
 223                         } else {
 224                                 directionVector = Vector<int>(0, -map->Tileset()->Height());
 225                         }
 226                         break;
 227                 case Entity::ORIENTATION_EAST:
 228                         if (tile && tile->BlocksEast()) {
 229                                 return true;
 230                         } else {
 231                                 directionVector = Vector<int>(map->Tileset()->Width(), 0);
 232                         }
 233                         break;
 234                 case Entity::ORIENTATION_SOUTH:
 235                         if (tile && tile->BlocksSouth()) {
 236                                 return true;
 237                         } else {
 238                                 directionVector = Vector<int>(0, map->Tileset()->Height());
 239                         }
 240                         break;
 241                 case Entity::ORIENTATION_WEST:
 242                         if (tile && tile->BlocksWest()) {
 243                                 return true;
 244                         } else {
 245                                 directionVector = Vector<int>(-map->Tileset()->Width(), 0);
 246                         }
 247                         break;
 248                 default:
 249                         return false;
 250         }
 251         Vector<int> nextTileCoords(map->TileCoordinates(directionVector + position));
 252         for (std::vector<Entity *>::const_iterator i(entities.begin()), end(entities.end()); i != end; ++i) {
 253                 const Entity &e(**i);
 254                 if (map->TileCoordinates(e.Position()) == nextTileCoords && e.Blocking()) {
 255                         return true;
 256                 }
 257         }
 258         return false;
 259 }
 260
 261 bool MapState::OnGridLock() {
 262         if (skipLock) {
 263                 skipLock = false;
 264                 return false;
 265         } else {
 266                 LockEntities();
 267                 return CheckMonster() || CheckTrigger();
 268         }
 269 }
 270
 271 void MapState::LockEntities() {
 272         for (std::vector<Entity *>::iterator i(entities.begin()), end(entities.end()); i != end; ++i) {
 273                 if (*i == controlled) {
 274                         // don't lock player
 275                         continue;
 276                 }
 277                 (*i)->Position().Lock(map->Tileset()->Size());
 278         }
 279 }
 280
 281 bool MapState::CheckMonster() {
 282         Vector<int> coords(map->TileCoordinates(controlled->Position()));
 283         Vector<int> neighbor[4];
 284         neighbor[0] = Vector<int>(coords.X(), coords.Y() - 1); // N
 285         neighbor[1] = Vector<int>(coords.X() + 1, coords.Y()); // E
 286         neighbor[2] = Vector<int>(coords.X(), coords.Y() + 1); // S
 287         neighbor[3] = Vector<int>(coords.X() - 1, coords.Y()); // W
 288
 289         for (int i(0); i < 4; ++i) {
 290                 for (std::vector<Entity *>::iterator e(entities.begin()), end(entities.end()); e != end; ++e) {
 291                         if ((*e)->Hostile() && map->TileCoordinates((*e)->Position()) == neighbor[i]) {
 292                                 // TODO: check for turn advantage, see #26
 293                                 // TODO: other transition
 294                                 BattleState *battleState(new BattleState(game, map->BattleBackgroundAt((*e)->Position()), (*e)->PartyLayout()));
 295                                 for (int i(0); i < 4; ++i) {
 296                                         if (game->state->party[i]) {
 297                                                 battleState->AddHero(*game->state->party[i]);
 298                                         }
 299                                 }
 300                                 for (battle::Monster *monster((*e)->MonstersBegin()); monster != (*e)->MonstersEnd(); ++monster) {
 301                                         battleState->AddMonster(*monster);
 302                                 }
 303
 304                                 ColorFade *fadeIn(new ColorFade(this, 0, 500, true));
 305                                 fadeIn->SetLeadInTime(500);
 306                                 ColorFade *fadeOut(new ColorFade(this, 0, 500));
 307                                 fadeOut->SetLeadOutTime(500);
 308
 309                                 ctrl->PushState(fadeIn);
 310                                 ctrl->PushState(battleState);
 311                                 ctrl->PushState(fadeOut);
 312                                 // TODO: move entity erase to happen after the transition or battle
 313                                 entities.erase(e);
 314                                 return true;
 315                                 // needed information here:
 316                                 //  - battle background (from tile/area/map)
 317                                 //  - monsters + layout (from entity)
 318                         }
 319                 }
 320         }
 321         return false;
 322 }
 323
 324 bool MapState::CheckTrigger() {
 325         Trigger *trigger(map->TriggerAt(Vector<int>(controlled->Position())));
 326         if (trigger) {
 327                 // TODO: run trigger script
 328                 if (trigger->map) {
 329                         ctrl->PushState(new ColorFade(this, 0, 500, true));
 330                         ctrl->PushState(new TransitionState(this, trigger->map, trigger->target));
 331                         ColorFade *fadeOut(new ColorFade(this, 0, 500, false));
 332                         fadeOut->SetLeadOutTime(500);
 333                         ctrl->PushState(fadeOut);
 334                         return true;
 335                 }
 336         }
 337         return false;
 338 }
 339
 340 void MapState::OnMove(bool realMove) {
 341         // TODO: evaluate monster movements
 342         if (realMove) {
 343                 UpdateFollower(*controlled);
 344         } else {
 345                 StopFollowers(*controlled);
 346         }
 347 }
 348
 349 void MapState::UpdateFollower(Entity &e) {
 350         if (!e.Follower()) return;
 351
 352         Entity &f(*e.Follower());
 353         UpdateFollower(f);
 354
 355         Vector<int> coords(map->TileCoordinates(e.Position()));
 356         Vector<int> fCoords(map->TileCoordinates(f.Position()));
 357         Vector<int> direction(coords - fCoords);
 358
 359         if (direction.Y() < 0) {
 360                 f.SetOrientation(Entity::ORIENTATION_NORTH);
 361                 f.SetSpeed(walkingSpeed);
 362                 f.StartAnimation(*this);
 363         } else if (direction.X() > 0) {
 364                 f.SetOrientation(Entity::ORIENTATION_EAST);
 365                 f.SetSpeed(walkingSpeed);
 366                 f.StartAnimation(*this);
 367         } else if (direction.Y() > 0) {
 368                 f.SetOrientation(Entity::ORIENTATION_SOUTH);
 369                 f.SetSpeed(walkingSpeed);
 370                 f.StartAnimation(*this);
 371         } else if (direction.X() < 0) {
 372                 f.SetOrientation(Entity::ORIENTATION_WEST);
 373                 f.SetSpeed(walkingSpeed);
 374                 f.StartAnimation(*this);
 375         } else {
 376                 f.SetSpeed(0.0f);
 377                 f.StopAnimation();
 378         }
 379 }
 380
 381 void MapState::StopFollowers(Entity &e) {
 382         for (Entity *f(e.Follower()); f; f = f->Follower()) {
 383                 f->SetSpeed(0.0f);
 384                 f->StopAnimation();
 385         }
 386 }
 387
 388
 389 void MapState::Transition(Map *newMap, const Vector<int> &coordinates) {
 390         UnloadMap();
 391         Vector<int> position(coordinates * map->Tileset()->Size());
 392         for (Entity *e(controlled); e; e = e->Follower()) {
 393                 e->Position() = position;
 394                 e->SetOrientation(controlled->GetOrientation());
 395         }
 396         LoadMap(newMap);
 397         skipLock = true;
 398 }
 399
 400 void MapState::UnloadMap() {
 401         entities.clear();
 402 }
 403
 404 void MapState::LoadMap(Map *m) {
 405         map = m;
 406         for (Entity *e(m->EntitiesBegin()), *end(m->EntitiesEnd()); e != end; ++e) {
 407                 entities.push_back(e);
 408         }
 409         for (Entity *e(controlled); e; e = e->Follower()) {
 410                 entities.push_back(e);
 411         }
 412 }
 413
 414
 415 void MapState::Render(SDL_Surface *screen) {
 416         SDL_FillRect(screen, 0, SDL_MapRGB(screen->format, 0, 0, 0));
 417
 418         Vector<int> offset(camera.CalculateOffset());
 419         map->Render(screen, offset);
 420
 421         if (debug) {
 422                 map->RenderDebug(screen, offset);
 423         }
 424
 425         std::sort(entities.begin(), entities.end(), ZCompare);
 426         for (std::vector<Entity *>::iterator i(entities.begin()), end(entities.end()); i != end; ++i) {
 427                 (*i)->Render(screen, offset);
 428         }
 429 }
 430
 431
 432 bool MapState::ZCompare(const Entity *lhs, const Entity *rhs) {
 433         return lhs->Position().Y() < rhs->Position().Y();
 434 }
 435
 436 }