src/world.cpp

   1 /*********************************
   2 ** Tsunagari Tile Engine        **
   3 ** world.cpp                    **
   4 ** Copyright 2011-2012 OmegaSDG **
   5 *********************************/
   6
   7 #include <Gosu/Utility.hpp>
   8
   9 #include "area-tmx.h"
  10 #include "log.h"
  11 #include "python.h"
  12 #include "resourcer.h"
  13 #include "timeout.h"
  14 #include "window.h"
  15 #include "world.h"
  16 #include "xml.h"
  17
  18 #define ASSERT(x)  if (!(x)) return false
  19
  20 static World* globalWorld = NULL;
  21
  22 World* World::instance()
  23 {
  24         return globalWorld;
  25 }
  26
  27 World::World()
  28         : music(new Music()), player(NULL)
  29 {
  30         globalWorld = this;
  31         pythonSetGlobal("World", this);
  32 }
  33
  34 World::~World()
  35 {
  36 }
  37
  38 bool World::init()
  39 {
  40         if (!processDescriptor()) // Try to load in descriptor.
  41                 return false;
  42
  43         if (!player.init(playerentity))
  44                 return false;
  45         player.setPhase("down");
  46
  47         if (onLoadScript.size()) {
  48                 pythonSetGlobal("Player", (Entity*)&player);
  49                 Resourcer* rc = Resourcer::instance();
  50                 rc->runPythonScript(onLoadScript);
  51         }
  52
  53         view.reset(new Viewport(viewport));
  54         view->trackEntity(&player);
  55
  56         Area* area = getArea(entry.area);
  57         if (!area)
  58                 return false;
  59         focusArea(area, entry.coords);
  60         return true;
  61 }
  62
  63 void World::buttonDown(const Gosu::Button btn)
  64 {
  65         area->buttonDown(btn);
  66 }
  67
  68 void World::buttonUp(const Gosu::Button btn)
  69 {
  70         area->buttonUp(btn);
  71 }
  72
  73 void World::draw()
  74 {
  75         GameWindow& window = GameWindow::instance();
  76         Gosu::Graphics& graphics = window.graphics();
  77
  78         drawLetterbox();
  79         drawAreaBorders();
  80         graphics.pushTransform(getTransform());
  81         area->draw();
  82         graphics.popTransform();
  83 }
  84
  85 bool World::needsRedraw() const
  86 {
  87         return area->needsRedraw();
  88 }
  89
  90 void World::update(unsigned long dt)
  91 {
  92         area->update(dt);
  93         updateTimeouts();
  94 }
  95
  96 Area* World::getArea(const std::string& filename)
  97 {
  98         AreaMap::iterator entry = areas.find(filename);
  99         if (entry != areas.end())
 100                 return entry->second;
 101
 102         Area* newArea = new AreaTMX(view.get(), &player, music.get(), filename);
 103
 104         if (!newArea->init())
 105                 newArea = NULL;
 106         areas[filename] = newArea;
 107         return newArea;
 108 }
 109
 110 Area* World::getFocusedArea()
 111 {
 112         return area;
 113 }
 114
 115 void World::focusArea(Area* area, int x, int y, double z)
 116 {
 117         focusArea(area, vicoord(x, y, z));
 118 }
 119
 120 void World::focusArea(Area* area, vicoord playerPos)
 121 {
 122         // Log::info("World", area->getDescriptor() + ": focused");
 123         this->area = area;
 124         player.setArea(area);
 125         player.setTileCoords(playerPos);
 126         view->setArea(area);
 127         area->focus();
 128 }
 129
 130 std::string World::getAreaLoadScript()
 131 {
 132         return onAreaLoadScript;
 133 }
 134
 135 bool World::processDescriptor()
 136 {
 137         XMLRef doc;
 138         XMLNode root;
 139
 140         Resourcer* rc = Resourcer::instance();
 141         ASSERT(doc = rc->getXMLDoc("world.conf", "world.dtd"));
 142         ASSERT(root = doc->root()); // <world>
 143
 144         for (XMLNode child = root.childrenNode(); child; child = child.next()) {
 145                 if (child.is("info")) {
 146                         ASSERT(processInfo(child));
 147                 }
 148                 else if (child.is("init")) {
 149                         ASSERT(processInit(child));
 150                 }
 151                 else if (child.is("script")) {
 152                         ASSERT(processScript(child));
 153                 }
 154                 else if (child.is("input")) {
 155                         ASSERT(processInput(child));
 156                 }
 157         }
 158
 159         if (conf.moveMode == TURN &&
 160            (conf.persistInit == 0 || conf.persistCons == 0)) {
 161                 Log::fatal("world.conf", "\"input->persist\" option required in TURN mode.");
 162                 return false;
 163         }
 164
 165         return true;
 166 }
 167
 168 bool World::processInfo(XMLNode node)
 169 {
 170         for (node = node.childrenNode(); node; node = node.next()) {
 171                 if (node.is("name")) {
 172                         name = node.content();
 173                         GameWindow::instance().setCaption(Gosu::widen(name));
 174                 } else if (node.is("author")) {
 175                         author = node.content();
 176                 } else if (node.is("version")) {
 177                         version = atof(node.content().c_str());
 178                 }
 179         }
 180         return true;
 181 }
 182
 183 bool World::processInit(XMLNode node)
 184 {
 185         for (node = node.childrenNode(); node; node = node.next()) {
 186                 if (node.is("area")) {
 187                         entry.area = node.content();
 188                 }
 189                 else if (node.is("player")) {
 190                         playerentity = node.content();
 191                 }
 192                 else if (node.is("mode")) {
 193                         std::string str = node.content();
 194                         if (str == "turn")
 195                                 conf.moveMode = TURN;
 196                         else if (str == "tile")
 197                                 conf.moveMode = TILE;
 198                         else if (str == "notile")
 199                                 conf.moveMode = NOTILE;
 200                 }
 201                 else if (node.is("coords")) {
 202                         if (!node.intAttr("x", &entry.coords.x) ||
 203                             !node.intAttr("y", &entry.coords.y) ||
 204                             !node.doubleAttr("z", &entry.coords.z))
 205                                 return false;
 206                 }
 207                 else if (node.is("viewport")) {
 208                         if (!node.intAttr("width", &viewport.x) ||
 209                             !node.intAttr("height", &viewport.y))
 210                                 return false;
 211                 }
 212         }
 213         return true;
 214 }
 215
 216 bool World::processScript(XMLNode node)
 217 {
 218         for (node = node.childrenNode(); node; node = node.next()) {
 219                 if (node.is("on_init")) {
 220                         std::string filename = node.content();
 221                         if (rc->resourceExists(filename)) {
 222                                 onLoadScript = filename;
 223                         }
 224                         else {
 225                                 Log::err("world.conf",
 226                                         std::string("script not found: ") + filename);
 227                                 return false;
 228                         }
 229                 } else if (node.is("on_area_init")) {
 230                         std::string filename = node.content();
 231                         if (rc->resourceExists(filename)) {
 232                                 onAreaLoadScript = filename;
 233                         }
 234                         else {
 235                                 Log::err("world.conf",
 236                                         std::string("script not found: ") + filename);
 237                                 return false;
 238                         }
 239                 }
 240         }
 241         return true;
 242 }
 243
 244 bool World::processInput(XMLNode node)
 245 {
 246         for (node = node.childrenNode(); node; node = node.next()) {
 247                 if (node.is("persist")) {
 248                         if (!node.intAttr("init", &conf.persistInit) ||
 249                                 !node.intAttr("cons", &conf.persistCons))
 250                             return false;
 251                 }
 252         }
 253         return true;
 254 }
 255
 256 void World::drawLetterbox()
 257 {
 258         rvec2 sz = view->getPhysRes();
 259         rvec2 lb = rvec2(0.0, 0.0);
 260         lb -= view->getLetterboxOffset();
 261         Gosu::Color black = Gosu::Color::BLACK;
 262
 263         drawRect(0, sz.x, 0, lb.y, black, 1000);
 264         drawRect(0, sz.x, sz.y - lb.y, sz.y, black, 1000);
 265         drawRect(0, lb.x, 0, sz.y, black, 1000);
 266         drawRect(sz.x - lb.x, sz.x, 0, sz.y, black, 1000);
 267 }
 268
 269 void World::drawAreaBorders()
 270 {
 271         Gosu::Color black = Gosu::Color::BLACK;
 272         rvec2 sz = view->getPhysRes();
 273         rvec2 scale = view->getScale();
 274         rvec2 virtScroll = view->getMapOffset();
 275         rvec2 padding = view->getLetterboxOffset();
 276
 277         rvec2 physScroll = virtScroll;
 278         physScroll *= scale;
 279         physScroll += padding;
 280         physScroll *= -1;
 281
 282         bool loopX = area->loopsInX();
 283         bool loopY = area->loopsInY();
 284
 285         if (!loopX && physScroll.x > 0) {
 286                 // Boxes on left-right.
 287                 drawRect(0, physScroll.x, 0, sz.y, black, 500);
 288                 drawRect(sz.x - physScroll.x, sz.x, 0, sz.y, black, 500);
 289         }
 290         if (!loopY && physScroll.y > 0) {
 291                 // Boxes on top-bottom.
 292                 drawRect(0, sz.x, 0, physScroll.y, black, 500);
 293                 drawRect(0, sz.x, sz.y - physScroll.y, sz.y, black, 500);
 294         }
 295 }
 296
 297 void World::drawRect(double x1, double x2, double y1, double y2,
 298                        Gosu::Color c, double z)
 299 {
 300         GameWindow& window = GameWindow::instance();
 301         window.graphics().drawQuad(
 302                 x1, y1, c,
 303                 x2, y1, c,
 304                 x2, y2, c,
 305                 x1, y2, c,
 306                 z
 307         );
 308 }
 309
 310 Gosu::Transform World::getTransform()
 311 {
 312         rvec2 scale = view->getScale();
 313         rvec2 scroll = view->getMapOffset();
 314         rvec2 padding = view->getLetterboxOffset();
 315         Gosu::Transform t = { {
 316                 scale.x, 0,       0, 0,
 317                 0,       scale.y, 0, 0,
 318                 0,       0,       1, 0,
 319                 scale.x * -scroll.x - padding.x,
 320                 scale.y * -scroll.y - padding.y, 0, 1
 321         } };
 322         return t;
 323 }
 324
 325 void exportWorld()
 326 {
 327         using namespace boost::python;
 328
 329         class_<World> ("World", no_init)
 330                 .def("area", &World::getArea,
 331                         return_value_policy<reference_existing_object>())
 332                 .def("focus",
 333                         static_cast<void (World::*) (Area*,int,int,double)>
 334                         (&World::focusArea))
 335                 ;
 336 }
 337