src/world.h

   1 /***************************************
   2 ** Tsunagari Tile Engine              **
   3 ** world.h                            **
   4 ** Copyright 2011-2013 PariahSoft LLC **
   5 ***************************************/
   6
   7 // **********
   8 // Permission is hereby granted, free of charge, to any person obtaining a copy
   9 // of this software and associated documentation files (the "Software"), to
  10 // deal in the Software without restriction, including without limitation the
  11 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  12 // sell copies of the Software, and to permit persons to whom the Software is
  13 // furnished to do so, subject to the following conditions:
  14 //
  15 // The above copyright notice and this permission notice shall be included in
  16 // all copies or substantial portions of the Software.
  17 //
  18 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  23 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  24 // IN THE SOFTWARE.
  25 // **********
  26
  27 #ifndef WORLD_H
  28 #define WORLD_H
  29
  30 #include <memory>
  31 #include <stack>
  32 #include <string>
  33 #include <vector>
  34
  35 #include <Gosu/Graphics.hpp> // for Gosu::Transform
  36
  37 #include "bitrecord.h"
  38 #include "music.h"
  39 #include "player.h"
  40 #include "script.h"
  41 #include "viewport.h"
  42
  43 namespace Gosu {
  44         class Button;
  45 }
  46
  47 class Area;
  48 class GameWindow;
  49
  50 /**
  51  * Top class holding all data necessary to create a game. Such a collection of
  52  * data is called a "world". Materially, a world is just a set of graphics,
  53  * sound effects, music, and scripts. From the perspective from a player, each
  54  * world should be a separate game. Tsunagari is an engine that powers worlds.
  55  */
  56 class World
  57 {
  58 public:
  59         /**
  60          * Get the currently open World.
  61          */
  62         static World* instance();
  63
  64         World();
  65         ~World();
  66
  67         /**
  68          * Initialize the world for use.
  69          */
  70         bool init();
  71
  72         /**
  73          * User's friendly name for this map.
  74          */
  75         const std::string& getName() const;
  76
  77         /**
  78          * Syncronized time value used throughout the engine.
  79          */
  80         time_t time() const;
  81
  82         /**
  83          * Process key presses.
  84          */
  85         void buttonDown(const Gosu::Button btn);
  86         void buttonUp(const Gosu::Button btn);
  87
  88         /**
  89          * Draw game state to the screen.
  90          */
  91         void draw();
  92
  93         /**
  94          * Do we need to redraw the screen?
  95          */
  96         bool needsRedraw() const;
  97
  98         void update(time_t now);
  99
 100         /**
 101          * Updates the game state within this World as if dt milliseconds had
 102          * passed since the last call.
 103          *
 104          *                       MOVE MODE
 105          *                 TURN     TILE     NOTILE
 106          * Area            yes      yes      yes
 107          * Character       no       yes      yes
 108          * Overlay         yes      yes      yes
 109          */
 110         void tick(unsigned long dt);
 111
 112         /**
 113          * Update the game world when the turn is over (Player moves).
 114          *
 115          *                       MOVE MODE
 116          *                 TURN     TILE     NOTILE
 117          * Area            yes      no       no
 118          * Character       yes      no       no
 119          * Overlay         yes      no       no
 120          */
 121         void turn();
 122
 123         /**
 124          * Create a new Area object, loading from the appropriate files. If
 125          * the Area has already been loaded previously, return that instance.
 126          */
 127         Area* getArea(const std::string& filename);
 128
 129         /**
 130          * Returns the currently focused Area.
 131          */
 132         Area* getFocusedArea();
 133
 134         /**
 135          * Switch the game to a new Area, moving the player to the specified
 136          * position in the Area.
 137          */
 138         void focusArea(Area* area, int x, int y, double z);
 139         void focusArea(Area* area, vicoord playerPos);
 140
 141         void setPaused(bool b);
 142
 143         void storeKeys();
 144         void restoreKeys();
 145
 146         void runAreaLoadScript(Area* area);
 147
 148         Music* getMusic();
 149
 150         ScriptRef keydownScript, keyupScript;
 151
 152 protected:
 153         /**
 154          * Calculate time passed since engine state was last updated.
 155          */
 156         time_t calculateDt(time_t now);
 157
 158         /**
 159          * Draws black borders around the screen. Used to correct the aspect
 160          * ratio and optimize drawing if the Area doesn't fit into the
 161          * Viewport.
 162          */
 163         int pushLetterbox();
 164         void popLetterbox(int clips);
 165
 166         /**
 167          * Draws a rectangle on the screen of the specified color. Coordinates
 168          * are in pixels.
 169          */
 170         void drawRect(double x1, double x2, double y1, double y2,
 171                       Gosu::Color c, double z);
 172
 173         /**
 174          * Returns an affine transformation that will zoom and pan the Area to
 175          * fit on-screen.
 176          */
 177         Gosu::Transform getTransform();
 178
 179         bool processDescriptor();
 180         bool processInfo(XMLNode node);
 181         bool processInit(XMLNode node);
 182         bool processScript(XMLNode node);
 183         bool processInput(XMLNode node);
 184
 185 protected:
 186         typedef std::map<std::string, Area*> AreaMap;
 187
 188
 189         std::string name;
 190         std::string author;
 191         double version;
 192         icoord viewportSz;
 193
 194
 195         std::string playerEntity;
 196         std::string startArea;
 197         vicoord startCoords;
 198
 199
 200         ScriptRef loadScript;
 201         ScriptRef areaLoadScript;
 202         ImageRef pauseInfo;
 203
 204
 205         AreaMap areas;
 206         Area* area;
 207         Music music;
 208         Player player;
 209         std::string playerPhase;
 210         std::shared_ptr<Viewport> view;
 211
 212
 213         /**
 214          * Last time engine state was updated. See World::update().
 215          */
 216         time_t lastTime;
 217
 218         /**
 219          * Total unpaused game run time.
 220          */
 221         time_t total;
 222
 223
 224         bool redraw;
 225         bool userPaused;
 226         int paused;
 227
 228
 229         std::stack<BitRecord> keyStates;
 230 };
 231
 232 void exportWorld();
 233
 234 #endif
 235