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