src/area.cpp

   1 /*********************************
   2 ** Tsunagari Tile Engine        **
   3 ** area.cpp                     **
   4 ** Copyright 2011-2012 OmegaSDG **
   5 *********************************/
   6
   7 #include <algorithm>
   8 #include <math.h>
   9 #include <stdlib.h> // for exit(1) on fatal
  10 #include <vector>
  11
  12 #include <boost/foreach.hpp>
  13 #include <boost/format.hpp>
  14 #include <boost/shared_ptr.hpp>
  15 #include <Gosu/Graphics.hpp>
  16 #include <Gosu/Image.hpp>
  17 #include <Gosu/Math.hpp>
  18 #include <Gosu/Timing.hpp>
  19
  20 #include "area.h"
  21 #include "entity.h"
  22 #include "log.h"
  23 #include "npc.h"
  24 #include "python.h"
  25 #include "resourcer.h"
  26 #include "tile.h"
  27 #include "window.h"
  28 #include "world.h"
  29
  30 #define ASSERT(x)  if (!(x)) return false
  31
  32 /* NOTE: In the TMX map format used by Tiled, tileset tiles start counting
  33          their Y-positions from 0, while layer tiles start counting from 1. I
  34          can't imagine why the author did this, but we have to take it into
  35          account.
  36 */
  37
  38 template<class T>
  39 static T wrap(T min, T value, T max)
  40 {
  41         while (value < min)
  42                 value += max;
  43         return value % max;
  44 }
  45
  46 Area::Area(Viewport* view,
  47            Player* player,
  48            Music* music,
  49            const std::string& descriptor)
  50         : view(view),
  51           player(player),
  52           music(music),
  53           colorOverlay(0, 0, 0, 0),
  54           dim(0, 0, 0),
  55           tileDim(0, 0),
  56           loopX(false), loopY(false),
  57           beenFocused(false),
  58           redraw(true),
  59           descriptor(descriptor)
  60 {
  61 }
  62
  63 Area::~Area()
  64 {
  65 }
  66
  67 bool Area::init()
  68 {
  69         // Abstract method.
  70         return false;
  71 }
  72
  73 void Area::focus()
  74 {
  75         if (!beenFocused) {
  76                 beenFocused = true;
  77                 runLoadScripts();
  78         }
  79
  80         music->setIntro(musicIntro);
  81         music->setLoop(musicLoop);
  82
  83         pythonSetGlobal("Area", this);
  84         focusScript.invoke();
  85 }
  86
  87 void Area::buttonDown(const Gosu::Button btn)
  88 {
  89         if (btn == Gosu::kbRight)
  90                 player->startMovement(ivec2(1, 0));
  91         else if (btn == Gosu::kbLeft)
  92                 player->startMovement(ivec2(-1, 0));
  93         else if (btn == Gosu::kbUp)
  94                 player->startMovement(ivec2(0, -1));
  95         else if (btn == Gosu::kbDown)
  96                 player->startMovement(ivec2(0, 1));
  97         else if (btn == Gosu::kbSpace)
  98                 player->useTile();
  99 }
 100
 101 void Area::buttonUp(const Gosu::Button btn)
 102 {
 103         if (btn == Gosu::kbRight)
 104                 player->stopMovement(ivec2(1, 0));
 105         else if (btn == Gosu::kbLeft)
 106                 player->stopMovement(ivec2(-1, 0));
 107         else if (btn == Gosu::kbUp)
 108                 player->stopMovement(ivec2(0, -1));
 109         else if (btn == Gosu::kbDown)
 110                 player->stopMovement(ivec2(0, 1));
 111 }
 112
 113 void Area::draw()
 114 {
 115         updateTileAnimations();
 116         drawTiles();
 117         drawEntities();
 118         drawColorOverlay();
 119         redraw = false;
 120 }
 121
 122 bool Area::needsRedraw() const
 123 {
 124         if (redraw)
 125                 return true;
 126         if (player->needsRedraw())
 127                 return true;
 128
 129         BOOST_FOREACH(Entity* e, entities)
 130                 if (e->needsRedraw())
 131                         return true;
 132
 133         // Do any on-screen tile types need to update their animations?
 134         const icube tiles = visibleTiles();
 135         for (int z = tiles.z1; z < tiles.z2; z++) {
 136                 for (int y = tiles.y1; y < tiles.y2; y++) {
 137                         for (int x = tiles.x1; x < tiles.x2; x++) {
 138                                 const Tile* tile = getTile(x, y, z);
 139                                 const TileType* type = tile->getType();
 140                                 if (type && type->needsRedraw())
 141                                         return true;
 142                         }
 143                 }
 144         }
 145         return false;
 146 }
 147
 148 void Area::requestRedraw()
 149 {
 150         redraw = true;
 151 }
 152
 153 void Area::update(unsigned long dt)
 154 {
 155         pythonSetGlobal("Area", this);
 156         updateScript.invoke();
 157
 158         pythonSetGlobal("Area", this);
 159         player->update(dt);
 160
 161         BOOST_FOREACH(Entity* e, entities)
 162                 e->update(dt);
 163
 164         view->update(dt);
 165         music->update();
 166 }
 167
 168 void Area::setColorOverlay(int r, int g, int b, int a)
 169 {
 170         using namespace Gosu;
 171
 172         if (0 <= r && r < 256 &&
 173             0 <= g && g < 256 &&
 174             0 <= b && b < 256 &&
 175             0 <= a && a < 256) {
 176                 Color::Channel ac = (Color::Channel)a;
 177                 Color::Channel rc = (Color::Channel)r;
 178                 Color::Channel gc = (Color::Channel)g;
 179                 Color::Channel bc = (Color::Channel)b;
 180                 colorOverlay = Color(ac, rc, gc, bc);
 181                 redraw = true;
 182         }
 183         else {
 184                 PyErr_Format(PyExc_ValueError,
 185                         "Area::color_overlay() arguments must be "
 186                         "between 0 and 255");
 187         }
 188 }
 189
 190
 191
 192 const Tile* Area::getTile(int x, int y, int z) const
 193 {
 194         if (loopX)
 195                 x = wrap(0, x, dim.x);
 196         if (loopY)
 197                 y = wrap(0, y, dim.y);
 198         if (inBounds(x, y, z))
 199                 return &map[z][y][x];
 200         else
 201                 return NULL;
 202 }
 203
 204 const Tile* Area::getTile(int x, int y, double z) const
 205 {
 206         return getTile(x, y, depthIndex(z));
 207 }
 208
 209 const Tile* Area::getTile(icoord phys) const
 210 {
 211         return getTile(phys.x, phys.y, phys.z);
 212 }
 213
 214 const Tile* Area::getTile(vicoord virt) const
 215 {
 216         return getTile(virt2phys(virt));
 217 }
 218
 219 const Tile* Area::getTile(rcoord virt) const
 220 {
 221         return getTile(virt2phys(virt));
 222 }
 223
 224 Tile* Area::getTile(int x, int y, int z)
 225 {
 226         if (loopX)
 227                 x = wrap(0, x, dim.x);
 228         if (loopY)
 229                 y = wrap(0, y, dim.y);
 230         if (inBounds(x, y, z))
 231                 return &map[z][y][x];
 232         else
 233                 return NULL;
 234 }
 235
 236 Tile* Area::getTile(int x, int y, double z)
 237 {
 238         return getTile(x, y, depthIndex(z));
 239 }
 240
 241 Tile* Area::getTile(icoord phys)
 242 {
 243         return getTile(phys.x, phys.y, phys.z);
 244 }
 245
 246 Tile* Area::getTile(vicoord virt)
 247 {
 248         return getTile(virt2phys(virt));
 249 }
 250
 251 Tile* Area::getTile(rcoord virt)
 252 {
 253         return getTile(virt2phys(virt));
 254 }
 255
 256 TileSet* Area::getTileSet(const std::string& imagePath)
 257 {
 258         std::map<std::string, TileSet>::iterator it;
 259         it = tileSets.find(imagePath);
 260         if (it == tileSets.end()) {
 261                 Log::err("Area", "tileset " + imagePath + " not found");
 262                 return NULL;
 263         }
 264         return &tileSets[imagePath];
 265 }
 266
 267
 268 ivec3 Area::getDimensions() const
 269 {
 270         return dim;
 271 }
 272
 273 ivec2 Area::getTileDimensions() const
 274 {
 275         return tileDim;
 276 }
 277
 278 icube Area::visibleTileBounds() const
 279 {
 280         rvec2 screen = view->getVirtRes();
 281         rvec2 off = view->getMapOffset();
 282
 283         int x1 = (int)floor(off.x / tileDim.x);
 284         int y1 = (int)floor(off.y / tileDim.y);
 285         int x2 = (int)ceil((screen.x + off.x) / tileDim.x);
 286         int y2 = (int)ceil((screen.y + off.y) / tileDim.y);
 287
 288         return icube(x1, y1, 0, x2, y2, dim.z);
 289 }
 290
 291 icube Area::visibleTiles() const
 292 {
 293         icube cube = visibleTileBounds();
 294         if (!loopX) {
 295                 cube.x1 = std::max(cube.x1, 0);
 296                 cube.x2 = std::min(cube.x2, dim.x);
 297         }
 298         if (!loopY) {
 299                 cube.y1 = std::max(cube.y1, 0);
 300                 cube.y2 = std::min(cube.y2, dim.y);
 301         }
 302         return cube;
 303 }
 304
 305 bool Area::inBounds(int x, int y, int z) const
 306 {
 307         return ((loopX || (0 <= x && x < dim.x)) &&
 308                 (loopY || (0 <= y && y < dim.y)) &&
 309                           0 <= z && z < dim.z);
 310 }
 311
 312 bool Area::inBounds(int x, int y, double z) const
 313 {
 314         return inBounds(x, y, depthIndex(z));
 315 }
 316
 317 bool Area::inBounds(icoord phys) const
 318 {
 319         return inBounds(phys.x, phys.y, phys.z);
 320 }
 321
 322 bool Area::inBounds(vicoord virt) const
 323 {
 324         return inBounds(virt2phys(virt));
 325 }
 326
 327 bool Area::inBounds(rcoord virt) const
 328 {
 329         return inBounds(virt2phys(virt));
 330 }
 331
 332 bool Area::inBounds(Entity* ent) const
 333 {
 334         return inBounds(ent->getPixelCoord());
 335 }
 336
 337
 338
 339 bool Area::loopsInX() const
 340 {
 341         return loopX;
 342 }
 343
 344 bool Area::loopsInY() const
 345 {
 346         return loopY;
 347 }
 348
 349 const std::string Area::getDescriptor() const
 350 {
 351         return descriptor;
 352 }
 353
 354 Entity* Area::spawnEntity(const std::string& descriptor,
 355         int x, int y, double z, const std::string& phase)
 356 {
 357         Entity* e = new NPC();
 358         if (!e->init(descriptor)) {
 359                 // Error logged.
 360                 delete e;
 361                 return NULL;
 362         }
 363         e->setArea(this);
 364         if (!e->setPhase(phase)) {
 365                 // Error logged.
 366                 delete e;
 367                 return NULL;
 368         }
 369         if (!inBounds(x, y, z)) {
 370                 Log::err(descriptor, boost::str(
 371                         boost::format("not in map bounds: x:%d y:%d z:%f")
 372                                 % x % y % z
 373                 ));
 374                 delete e;
 375                 return NULL;
 376         }
 377         e->setTileCoords(x, y, z);
 378         insert(e);
 379         return e;
 380 }
 381
 382 void Area::insert(Entity* e)
 383 {
 384         entities.insert(e);
 385 }
 386
 387 void Area::erase(Entity* e)
 388 {
 389         entities.erase(e);
 390 }
 391
 392
 393
 394 vicoord Area::phys2virt_vi(icoord phys) const
 395 {
 396         return vicoord(phys.x, phys.y, indexDepth(phys.z));
 397 }
 398
 399 rcoord Area::phys2virt_r(icoord phys) const
 400 {
 401         return rcoord(
 402                 (double)phys.x * tileDim.x,
 403                 (double)phys.y * tileDim.y,
 404                 indexDepth(phys.z)
 405         );
 406 }
 407
 408 icoord Area::virt2phys(vicoord virt) const
 409 {
 410         return icoord(virt.x, virt.y, depthIndex(virt.z));
 411 }
 412
 413 icoord Area::virt2phys(rcoord virt) const
 414 {
 415         return icoord(
 416                 (int)(virt.x / tileDim.x),
 417                 (int)(virt.y / tileDim.y),
 418                 depthIndex(virt.z)
 419         );
 420 }
 421
 422 rcoord Area::virt2virt(vicoord virt) const
 423 {
 424         return rcoord(
 425                 (double)virt.x * tileDim.x,
 426                 (double)virt.y * tileDim.y,
 427                 virt.z
 428         );
 429 }
 430
 431 vicoord Area::virt2virt(rcoord virt) const
 432 {
 433         return vicoord(
 434                 (int)virt.x / tileDim.x,
 435                 (int)virt.y / tileDim.y,
 436                 virt.z
 437         );
 438 }
 439
 440
 441 int Area::depthIndex(double depth) const
 442 {
 443         return depth2idx.find(depth)->second;
 444 }
 445
 446 double Area::indexDepth(int idx) const
 447 {
 448         return idx2depth[idx];
 449 }
 450
 451
 452
 453 void Area::runLoadScripts()
 454 {
 455         World* world = World::instance();
 456         world->runAreaLoadScript(this);
 457
 458         pythonSetGlobal("Area", this);
 459         loadScript.invoke();
 460 }
 461
 462 void Area::updateTileAnimations()
 463 {
 464         const int millis = GameWindow::instance().time();
 465         BOOST_FOREACH(tilesets_t::value_type& pair, tileSets) {
 466                 TileSet& set = pair.second;
 467                 int w = set.getWidth();
 468                 int h = set.getHeight();
 469                 for (int y = 0; y < h; y++) {
 470                         for (int x = 0; x < w; x++) {
 471                                 TileType* type = set.get(x, y);
 472                                 type->anim.updateFrame(millis);
 473                         }
 474                 }
 475         }
 476 }
 477
 478 void Area::drawTiles() const
 479 {
 480         const icube tiles = visibleTiles();
 481         for (int z = tiles.z1; z < tiles.z2; z++) {
 482                 double depth = idx2depth[z];
 483                 for (int y = tiles.y1; y < tiles.y2; y++) {
 484                         for (int x = tiles.x1; x < tiles.x2; x++) {
 485                                 const Tile* tile = getTile(x, y, z);
 486                                 drawTile(*tile, x, y, depth);
 487                         }
 488                 }
 489         }
 490 }
 491
 492 void Area::drawTile(const Tile& tile, int x, int y, double depth) const
 493 {
 494         const TileType* type = (TileType*)tile.parent;
 495         if (type) {
 496                 const Gosu::Image* img = type->anim.frame();
 497                 if (img)
 498                         img->draw((double)x*img->width(),
 499                                   (double)y*img->height(), depth);
 500         }
 501 }
 502
 503 void Area::drawEntities()
 504 {
 505         BOOST_FOREACH(Entity* e, entities) {
 506                 e->draw();
 507         }
 508         player->draw();
 509 }
 510
 511 void Area::drawColorOverlay()
 512 {
 513         if (colorOverlay.alpha() != 0) {
 514                 GameWindow& window = GameWindow::instance();
 515                 Gosu::Color c = colorOverlay;
 516                 int x = window.width();
 517                 int y = window.height();
 518                 window.graphics().drawQuad(
 519                         0, 0, c,
 520                         x, 0, c,
 521                         x, y, c,
 522                         0, y, c,
 523                         750
 524                 );
 525         }
 526 }
 527
 528 boost::python::tuple Area::pyGetDimensions()
 529 {
 530         using namespace boost::python;
 531
 532         list zs;
 533         BOOST_FOREACH(double dep, idx2depth)
 534                 zs.append(dep);
 535         return make_tuple(dim.x, dim.y, zs);
 536 }
 537
 538 void exportArea()
 539 {
 540         using namespace boost::python;
 541
 542         class_<Area>("Area", no_init)
 543                 .add_property("descriptor", &Area::getDescriptor)
 544                 .add_property("dimensions", &Area::pyGetDimensions)
 545                 .def("redraw", &Area::requestRedraw)
 546                 .def("tileset", &Area::getTileSet,
 547                     return_value_policy<reference_existing_object>())
 548                 .def("tile",
 549                     static_cast<Tile* (Area::*) (int, int, double)>
 550                     (&Area::getTile),
 551                     return_value_policy<reference_existing_object>())
 552                 .def("in_bounds",
 553                     static_cast<bool (Area::*) (int, int, double) const>
 554                     (&Area::inBounds))
 555                 .def("color_overlay", &Area::setColorOverlay)
 556                 .def("new_entity", &Area::spawnEntity,
 557                     return_value_policy<reference_existing_object>())
 558                 .def_readwrite("on_focus", &Area::focusScript)
 559                 .def_readwrite("on_update", &Area::updateScript)
 560                 ;
 561 }
 562