src/tile.cpp

   1 /*********************************
   2 ** Tsunagari Tile Engine        **
   3 ** tile.cpp                     **
   4 ** Copyright 2011-2012 OmegaSDG **
   5 *********************************/
   6
   7 #include <stdlib.h> // for exit(1) on fatal
   8
   9 #include <boost/foreach.hpp>
  10
  11 #include "area.h"
  12 #include "python.h"
  13 #include "python-optional.h"
  14 #include "string.h"
  15 #include "tile.h"
  16 #include "window.h"
  17
  18 static int ivec2_to_dir(ivec2 v)
  19 {
  20         switch (v.x) {
  21         case -1:
  22                 return v.y == 0 ? EXIT_LEFT : -1;
  23         case 0:
  24                 switch (v.y) {
  25                 case -1:
  26                         return EXIT_UP;
  27                 case 0:
  28                         return EXIT_NORMAL;
  29                 case 1:
  30                         return EXIT_DOWN;
  31                 default:
  32                         return -1;
  33                 }
  34                 break;
  35         case 1:
  36                 return v.y == 0 ? EXIT_RIGHT : -1;
  37         default:
  38                 return -1;
  39         }
  40 }
  41
  42 static Exit pythonNewExit(std::string area, int x, int y, double z)
  43 {
  44         return Exit(area, x, y, z);
  45 }
  46
  47
  48 /*
  49  * FLAGMANIP
  50  */
  51 FlagManip::FlagManip(unsigned* flags)
  52         : flags(flags)
  53 {
  54 }
  55
  56 bool FlagManip::isNowalk() const
  57 {
  58         return (*flags & TILE_NOWALK) != 0;
  59 }
  60
  61 bool FlagManip::isNowalkPlayer() const
  62 {
  63         return (*flags & TILE_NOWALK_PLAYER) != 0;
  64 }
  65
  66 bool FlagManip::isNowalkNPC() const
  67 {
  68         return (*flags & TILE_NOWALK_NPC) != 0;
  69 }
  70
  71 void FlagManip::setNowalk(bool nowalk)
  72 {
  73         *flags = (*flags & ~TILE_NOWALK) | TILE_NOWALK * nowalk;
  74 }
  75
  76 void FlagManip::setNowalkPlayer(bool nowalk)
  77 {
  78         *flags = (*flags & ~TILE_NOWALK_PLAYER) | TILE_NOWALK_PLAYER * nowalk;
  79 }
  80
  81 void FlagManip::setNowalkNPC(bool nowalk)
  82 {
  83         *flags = (*flags & ~TILE_NOWALK_NPC) | TILE_NOWALK_NPC * nowalk;
  84 }
  85
  86
  87 Exit::Exit()
  88 {
  89 }
  90
  91 Exit::Exit(const std::string area, int x, int y, double z)
  92         : area(area), coords(x, y, z)
  93 {
  94 }
  95
  96
  97 /*
  98  * TILEBASE
  99  */
 100 TileBase::TileBase()
 101         : parent(NULL), flags(0x0)
 102 {
 103 }
 104
 105 bool TileBase::hasFlag(unsigned flag) const
 106 {
 107         return flags & flag || (parent && parent->hasFlag(flag));
 108 }
 109
 110 FlagManip TileBase::flagManip()
 111 {
 112         return FlagManip(&flags);
 113 }
 114
 115 TileType* TileBase::getType() const
 116 {
 117         return (TileType*)parent;
 118 }
 119
 120 void TileBase::setType(TileType* type)
 121 {
 122         parent = type;
 123 }
 124
 125 void TileBase::onEnterScripts(Entity* triggeredBy)
 126 {
 127         runScripts(triggeredBy, onEnter);
 128         if (parent)
 129                 parent->onEnterScripts(triggeredBy);
 130 }
 131
 132 void TileBase::onLeaveScripts(Entity* triggeredBy)
 133 {
 134         runScripts(triggeredBy, onLeave);
 135         if (parent)
 136                 parent->onLeaveScripts(triggeredBy);
 137 }
 138
 139 void TileBase::onUseScripts(Entity* triggeredBy)
 140 {
 141         runScripts(triggeredBy, onUse);
 142         if (parent)
 143                 parent->onUseScripts(triggeredBy);
 144 }
 145
 146 void TileBase::runScripts(Entity* triggeredBy,
 147                       const std::vector<std::string>& events)
 148 {
 149         BOOST_FOREACH(const std::string& script, events) {
 150                 Resourcer* rc = Resourcer::instance();
 151                 pythonSetGlobal("Entity", triggeredBy);
 152                 pythonSetGlobal("Tile", this);
 153                 rc->runPythonScript(script);
 154         }
 155 }
 156
 157
 158 /*
 159  * TILE
 160  */
 161 Tile::Tile()
 162 {
 163 }
 164
 165 Tile::Tile(Area* area, int x, int y, int z)
 166         : TileBase(), area(area), x(x), y(y), z(z)
 167 {
 168         memset(exits, 0, sizeof(exits));
 169         memset(layermods, 0, sizeof(layermods));
 170 }
 171
 172 Tile& Tile::offset(int x, int y)
 173 {
 174         return area->getTile(this->x + x, this->y + y, z);
 175 }
 176
 177 double Tile::getZ()
 178 {
 179         vicoord vi = area->phys2virt_vi(icoord(x, y, z));
 180         return vi.z;
 181 }
 182
 183 Exit* Tile::getNormalExit() const
 184 {
 185         return exits[EXIT_NORMAL];
 186 }
 187
 188 void Tile::setNormalExit(Exit exit)
 189 {
 190         Exit** norm = &exits[EXIT_NORMAL];
 191         if (*norm)
 192                 delete *norm;
 193         *norm = new Exit(exit);
 194 }
 195
 196 Exit* Tile::exitAt(ivec2 dir) const
 197 {
 198         int idx = ivec2_to_dir(dir);
 199         return idx == -1 ? NULL : exits[idx];
 200 }
 201
 202 boost::optional<double> Tile::layermodAt(ivec2 dir) const
 203 {
 204         int idx = ivec2_to_dir(dir);
 205         return idx == -1 ? boost::optional<double>() : layermods[idx];
 206 }
 207
 208
 209 /*
 210  * TILETYPE
 211  */
 212 TileType::TileType()
 213         : TileBase()
 214 {
 215 }
 216
 217 TileType::TileType(ImageRef& img)
 218         : TileBase()
 219 {
 220         anim.addFrame(img);
 221 }
 222
 223 bool TileType::needsRedraw() const
 224 {
 225         const int millis = GameWindow::instance().time();
 226         return anim.needsRedraw(millis);
 227 }
 228
 229 /*
 230  * TILESET
 231  */
 232 TileSet::TileSet()
 233 {
 234 }
 235
 236 TileSet::TileSet(int width, int height)
 237         : width(width), height(height)
 238 {
 239 }
 240
 241 void TileSet::add(TileType* type)
 242 {
 243         types.push_back(type);
 244 }
 245
 246 void TileSet::set(int idx, TileType* type)
 247 {
 248         types[idx] = type;
 249 }
 250
 251 TileType& TileSet::get(int x, int y)
 252 {
 253         size_t i = idx(x, y);
 254         if (i > types.size()) {
 255                 Log::fatal("TileSet", "index " + itostr((int)i) + " out of bounds");
 256                 exit(1);
 257         }
 258         return *types[i];
 259 }
 260
 261 int TileSet::getWidth() const
 262 {
 263         return height;
 264 }
 265
 266 int TileSet::getHeight() const
 267 {
 268         return width;
 269 }
 270
 271 TileType& TileSet::pyGet(int x, int y)
 272 {
 273         size_t i = idx(x, y);
 274         if (i > types.size()) {
 275                 PyErr_SetString(PyExc_IndexError,
 276                         "TileSet::at(): x, y index out of range");
 277                 boost::python::throw_error_already_set();
 278         }
 279         return *types[i];
 280 }
 281
 282 size_t TileSet::idx(int x, int y) const
 283 {
 284         return y * width + x;
 285 }
 286
 287
 288 /*
 289  * PYTHON
 290  */
 291 void exportTile()
 292 {
 293         using namespace boost::python;
 294
 295         class_<FlagManip> ("FlagManipulator", no_init)
 296                 .add_property("nowalk",
 297                         &FlagManip::isNowalk, &FlagManip::setNowalk)
 298                 .add_property("nowalk_player",
 299                         &FlagManip::isNowalkPlayer, &FlagManip::setNowalkPlayer)
 300                 .add_property("nowalk_npc",
 301                         &FlagManip::isNowalkNPC, &FlagManip::setNowalkNPC)
 302                 ;
 303         class_<TileBase> ("TileBase", no_init)
 304                 .add_property("flag", &TileBase::flagManip)
 305                 .add_property("type",
 306                     make_function(
 307                       static_cast<TileType* (TileBase::*) () const>
 308                         (&TileBase::getType),
 309                       return_value_policy<reference_existing_object>()),
 310                     &TileBase::setType)
 311                 .def("run_enter_scripts", &TileBase::onEnterScripts)
 312                 .def("run_leave_scripts", &TileBase::onLeaveScripts)
 313                 .def("run_use_scripts", &TileBase::onUseScripts)
 314                 ;
 315         class_<Tile, bases<TileBase> > ("Tile", no_init)
 316                 .def_readonly("area", &Tile::area)
 317                 .def_readonly("x", &Tile::x)
 318                 .def_readonly("y", &Tile::y)
 319                 .add_property("z", &Tile::getZ)
 320                 .add_property("exit",
 321                     make_function(
 322                       static_cast<Exit* (Tile::*) () const>
 323                         (&Tile::getNormalExit),
 324                       return_value_policy<reference_existing_object>()),
 325                     &Tile::setNormalExit)
 326                 .def("offset", &Tile::offset,
 327                     return_value_policy<reference_existing_object>())
 328                 ;
 329         class_<TileType, bases<TileBase> > ("TileType", no_init)
 330                 ;
 331         class_<TileSet> ("TileSet", no_init)
 332                 .add_property("width", &TileSet::getWidth)
 333                 .add_property("height", &TileSet::getHeight)
 334                 .def("at", &TileSet::pyGet,
 335                     return_value_policy<reference_existing_object>())
 336                 ;
 337         class_<Exit> ("Exit", no_init)
 338                 .def_readwrite("area", &Exit::area)
 339                 .def_readwrite("coords", &Exit::coords)
 340                 ;
 341         pythonAddFunction("new_exit", pythonNewExit);
 342 }
 343