src/tile.h

   1 /*********************************
   2 ** Tsunagari Tile Engine        **
   3 ** tile.h                       **
   4 ** Copyright 2011-2012 OmegaSDG **
   5 *********************************/
   6
   7 #ifndef TILE_H
   8 #define TILE_H
   9
  10 #include <string>
  11 #include <vector>
  12
  13 #include <boost/optional.hpp>
  14
  15 #include "animation.h"
  16 #include "resourcer.h" // for TiledImage
  17 #include "scriptinst.h"
  18
  19 class Area;
  20 class Entity;
  21 class TileType;
  22
  23 //! List of possible flags that can be attached to a tile.
  24 /*!
  25         Flags are attached to tiles and denote special behavior for
  26         the tile they are bound to.
  27
  28         see AreaTMX::splitTileFlags().
  29 */
  30
  31 /**
  32  * TILE_NOWALK
  33  * Neither the player nor NPCs can walk here.
  34  */
  35 #define TILE_NOWALK          0x001
  36
  37 /**
  38  * TILE_NOWALK_PLAYER
  39  * The player cannot walk here. NPCs can, though.
  40  */
  41 #define TILE_NOWALK_PLAYER   0x002
  42
  43 /**
  44  * TILE_NOWALK_NPC
  45  * NPCs cannot walk here. The player can, though.
  46  */
  47 #define TILE_NOWALK_NPC      0x004
  48
  49 /**
  50  * TILE_NOWALK_EXIT
  51  * This Tile is an Exit. Please take appropriate action when entering this Tile,
  52  * usually by transferring to another Area.
  53  *
  54  * This flag is not carried by actual Tiles, but can instead be flipped in an
  55  * Entity's "exempt" flag which will be read elsewhere in the engine.
  56  */
  57 #define TILE_NOWALK_EXIT     0x008
  58
  59 /**
  60  * TILE_NOWALK_AREA_BOUND
  61  * This Tile is at the edge of an Area. If you step here, please handle it
  62  * appropriately.
  63  *
  64  * (Usually if one moves off a map bound, one will either transfer to another
  65  * Area, or will be destroyed.)
  66  *
  67  * This flag is not carried by actual Tiles, but can instead be flipped in an
  68  * Entity's "exempt" flag which will be read elsewhere in the engine.
  69  */
  70 #define TILE_NOWALK_AREA_BOUND 0x016
  71
  72
  73 /**
  74  * Types of exits.
  75  */
  76 enum ExitDirection {
  77         /**
  78          * An Exit that is taken upon arriving at the Tile.
  79          */
  80         EXIT_NORMAL,
  81         /**
  82          * An Exit that is taken when leaving in the upwards
  83          * direction from a Tile.
  84          */
  85         EXIT_UP,
  86         /**
  87          * An Exit that is taken when leaving in the downwards
  88          * direction from a Tile.
  89          */
  90         EXIT_DOWN,
  91         /**
  92          * An Exit that is taken when leaving to the left from
  93          * a Tile.
  94          */
  95         EXIT_LEFT,
  96         /**
  97          * An Exit that is taken when leaving to the right from
  98          * a Tile.
  99          */
 100         EXIT_RIGHT,
 101         EXITS_LENGTH
 102 };
 103
 104 /**
 105  * Independant object that can manipulate a Tile's flags.
 106  */
 107 class FlagManip
 108 {
 109 public:
 110         FlagManip(unsigned* flags);
 111
 112         bool isNowalk() const;
 113         bool isNowalkPlayer() const;
 114         bool isNowalkNPC() const;
 115         bool isNowalkExit() const;
 116         bool isNowalkAreaBound() const;
 117
 118         void setNowalk(bool nowalk);
 119         void setNowalkPlayer(bool nowalk);
 120         void setNowalkNPC(bool nowalk);
 121         void setNowalkExit(bool nowalk);
 122         void setNowalkAreaBound(bool nowalk);
 123
 124 private:
 125         unsigned* flags;
 126 };
 127
 128 //! Convenience trigger for inter-area teleportation.
 129 /*!
 130         Tiles with a exit trigger attached can teleport the player to a
 131         new area in the World. The Exit struct contains the destination
 132         area and coordinates.
 133 */
 134 class Exit {
 135 public:
 136         Exit();
 137         Exit(const std::string area, int x, int y, double z);
 138
 139 public:
 140         std::string area;
 141         vicoord coords;
 142 };
 143
 144 class TileBase
 145 {
 146 public:
 147         TileBase();
 148
 149         FlagManip flagManip();
 150
 151         //! Determines whether this tile or one of its parent types embodies a
 152         //! flag.
 153         bool hasFlag(unsigned flag) const;
 154
 155         TileType* getType() const;
 156         void setType(TileType* type);
 157
 158         void runEnterScript(Entity* triggeredBy);
 159         void runLeaveScript(Entity* triggeredBy);
 160         void runUseScript(Entity* triggeredBy);
 161
 162 private:
 163         void runScript(Entity* triggeredBy, ScriptInst& script);
 164
 165 public:
 166         TileBase* parent;
 167         unsigned flags;
 168         ScriptInst enterScript, leaveScript, useScript;
 169 };
 170
 171 //! Contains properties unique to this tile.
 172 /*!
 173         This struct contains local tile properties for a single tile in
 174         the area. As opposed to global properties which apply to all
 175         tiles of the same type, these properties will only apply to one
 176         tile.
 177 */
 178 class Tile : public TileBase
 179 {
 180 public:
 181         Tile(); // Should not be used. Wanted by std::containers.
 182         Tile(Area* area, int x, int y, int z);
 183
 184         /**
 185          * Gets the correct destination for an Entity wanting to
 186          * move off of this tile in <code>facing</code>
 187          * direction.
 188          *
 189          * This call is necessary to handle layermod.
 190          *
 191          * @param here    area-space coordinate for this Tile
 192          * @param facing  facing vector
 193          */
 194         icoord moveDest(icoord here, ivec2 facing) const;
 195         Tile* offset(int x, int y) const;
 196
 197         double getZ() const;
 198
 199         Exit* getNormalExit() const;
 200         void setNormalExit(Exit exit);
 201
 202         Exit* exitAt(ivec2 dir) const;
 203         boost::optional<double> layermodAt(ivec2 dir) const;
 204
 205 public:
 206         Area* area;
 207
 208         /*
 209          * The grid-space coordinates of this Tile.
 210          *
 211          * Looping Areas utilize area-space components. These
 212          * cannot be losslessly transformed into area-space.
 213          */
 214         int x, y, z;
 215         Exit* exits[EXITS_LENGTH];
 216         boost::optional<double> layermods[EXITS_LENGTH];
 217         int entCnt; //!< Number of entities on this Tile.
 218 };
 219
 220 //! Contains the properties shared by all tiles of a certain type.
 221 /*!
 222         This struct contains global tile properties for a tile of a
 223         certain type. As opposed to local properties for a single tile,
 224         all tiles of this type will share the defined characteristics.
 225 */
 226 class TileType : public TileBase
 227 {
 228 public:
 229         TileType();
 230         TileType(ImageRef& img);
 231
 232         //! Returns true if onscreen and we need to update our animation.
 233         bool needsRedraw() const;
 234
 235 public:
 236         Animation anim; //! Graphics for tiles of this type.
 237         std::vector<Tile*> allOfType;
 238 };
 239
 240 class TileSet
 241 {
 242 public:
 243         TileSet();
 244         TileSet(int width, int height);
 245
 246         void add(TileType* type);
 247         void set(int idx, TileType* type);
 248         TileType* get(int x, int y);
 249         int getWidth() const;
 250         int getHeight() const;
 251
 252 private:
 253         size_t idx(int x, int y) const;
 254
 255         std::vector<TileType*> types;
 256         int width, height;
 257 };
 258
 259 void exportTile();
 260
 261 #endif
 262