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