src/entity.cpp

   1 /***************************************
   2 ** Tsunagari Tile Engine              **
   3 ** entity.cpp                         **
   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 #include <math.h>
  28
  29 #include <boost/algorithm/string.hpp> // for iequals
  30 #include <Gosu/Image.hpp>
  31 #include <Gosu/Math.hpp>
  32 #include <Gosu/Timing.hpp>
  33
  34 #include "area.h"
  35 #include "client-conf.h"
  36 #include "entity.h"
  37 #include "log.h"
  38 #include "python.h"
  39 #include "python-bindings-template.cpp"
  40 #include "reader.h"
  41 #include "string.h"
  42 #include "world.h"
  43 #include "xml.h"
  44
  45 #define ASSERT(x)  if (!(x)) { return false; }
  46
  47 static std::string directions[][3] = {
  48         {"up-left",   "up",     "up-right"},
  49         {"left",      "stance", "right"},
  50         {"down-left", "down",   "down-right"},
  51 };
  52
  53
  54 Entity::Entity()
  55         : redraw(true),
  56           area(NULL),
  57           r(0.0, 0.0, 0.0),
  58           frozen(false),
  59           speedMul(1.0),
  60           moving(false),
  61           stillMoving(false),
  62           nowalkFlags(TILE_NOWALK | TILE_NOWALK_NPC),
  63           nowalkExempt(0),
  64           phase(NULL),
  65           phaseName("")
  66 {
  67 }
  68
  69 Entity::~Entity()
  70 {
  71         if (deleteScript) {
  72                 pythonSetGlobal("Area", area);
  73                 pythonSetGlobal("Entity", this);
  74                 deleteScript->invoke();
  75         }
  76 }
  77
  78 bool Entity::init(const std::string& descriptor)
  79 {
  80         this->descriptor = descriptor;
  81         return processDescriptor();
  82 }
  83
  84 void Entity::destroy()
  85 {
  86         leaveTile();
  87         if (area) {
  88                 erase();
  89                 area->requestRedraw();
  90         }
  91         area = NULL;
  92         delete this;
  93 }
  94
  95 void Entity::draw()
  96 {
  97         redraw = false;
  98         if (!phase)
  99                 return;
 100
 101         time_t now = World::instance()->time();
 102         Image* img = phase->frame(now);
 103
 104         img->draw(
 105                 doff.x + r.x,
 106                 doff.y + r.y,
 107                 r.z + area->isometricZOff(rvec2(r.x, r.y))
 108         );
 109 }
 110
 111 bool Entity::needsRedraw() const
 112 {
 113         time_t now = World::instance()->time();
 114         return redraw || (phase && phase->needsRedraw(now));
 115 }
 116
 117
 118 void Entity::tick(time_t dt)
 119 {
 120         runTickScript();
 121         switch (conf.moveMode) {
 122         case TURN:
 123                 tickTurn(dt);
 124                 break;
 125         case TILE:
 126                 tickTile(dt);
 127                 break;
 128         case NOTILE:
 129                 tickNoTile(dt);
 130                 break;
 131         }
 132 }
 133
 134 void Entity::tickTurn(time_t)
 135 {
 136         // FIXME Characters (!!) don't do anything in TILE mode.
 137 }
 138
 139 void Entity::tickTile(time_t dt)
 140 {
 141         if (!moving)
 142                 return;
 143
 144         redraw = true;
 145         double traveled = speed * (double)dt;
 146         double destDist = Gosu::distance(r.x, r.y, destCoord.x, destCoord.y);
 147         if (destDist <= traveled) {
 148                 r = destCoord;
 149                 moving = false;
 150                 postMove();
 151                 if (moving) {
 152                         // Time rollover.
 153                         double perc = 1.0 - destDist/traveled;
 154                         time_t remt = (time_t)(perc * (double)dt);
 155                         tick(remt);
 156                 }
 157         }
 158         else {
 159                 double angle = atan2(destCoord.y - r.y, destCoord.x - r.x);
 160                 double dx = cos(angle);
 161                 double dy = sin(angle);
 162
 163                 r.x += dx * traveled;
 164                 r.y += dy * traveled;
 165         }
 166 }
 167
 168 void Entity::tickNoTile(time_t)
 169 {
 170         // TODO
 171 }
 172
 173 void Entity::turn()
 174 {
 175         runTurnScript();
 176 }
 177
 178 const std::string Entity::getFacing() const
 179 {
 180         return directionStr(facing);
 181 }
 182
 183 bool Entity::setPhase(const std::string& name)
 184 {
 185         enum SetPhaseResult res;
 186         res = _setPhase(name);
 187         if (res == PHASE_NOTFOUND) {
 188                 res = _setPhase("stance");
 189                 if (res == PHASE_NOTFOUND)
 190                         Log::err(descriptor, "phase '" + name + "' not found");
 191         }
 192         return res == PHASE_CHANGED;
 193 }
 194
 195 std::string Entity::getPhase() const
 196 {
 197         return phaseName;
 198 }
 199
 200 rcoord Entity::getPixelCoord() const
 201 {
 202         return r;
 203 }
 204
 205 icoord Entity::getTileCoords_i() const
 206 {
 207         return area->virt2phys(r);
 208 }
 209
 210 vicoord Entity::getTileCoords_vi() const
 211 {
 212         return area->virt2virt(r);
 213 }
 214
 215 void Entity::setTileCoords(int x, int y)
 216 {
 217         leaveTile();
 218         vicoord virt(x, y, r.z);
 219         redraw = true;
 220         r = area->virt2virt(virt);
 221         enterTile();
 222 }
 223
 224 void Entity::setTileCoords(int x, int y, double z)
 225 {
 226         leaveTile();
 227         vicoord virt(x, y, z);
 228         redraw = true;
 229         r = area->virt2virt(virt);
 230         enterTile();
 231 }
 232
 233 void Entity::setTileCoords(icoord phys)
 234 {
 235         leaveTile();
 236         redraw = true;
 237         r = area->phys2virt_r(phys);
 238         enterTile();
 239 }
 240
 241 void Entity::setTileCoords(vicoord virt)
 242 {
 243         leaveTile();
 244         redraw = true;
 245         r = area->virt2virt(virt);
 246         enterTile();
 247 }
 248
 249 void Entity::setTileCoords(rcoord virt)
 250 {
 251         leaveTile();
 252         redraw = true;
 253         r = virt;
 254         enterTile();
 255 }
 256
 257 void Entity::teleport(int, int)
 258 {
 259         throw "pure virtual function";
 260 }
 261
 262 icoord Entity::moveDest(ivec2 facing)
 263 {
 264         Tile* tile = getTile();
 265         icoord here = getTileCoords_i();
 266
 267         if (tile)
 268                 // Handle layermod.
 269                 return tile->moveDest(here, facing);
 270         else
 271                 return here + icoord(facing.x, facing.y, 0);
 272 }
 273
 274 // Python API.
 275 vicoord Entity::moveDest(Tile* t, int dx, int dy)
 276 {
 277         icoord here = getTileCoords_i();
 278         icoord dest;
 279
 280         if (t) {
 281                 // Handle layermod.
 282                 dest = t->moveDest(here, ivec2(dx, dy));
 283                 return t->area->phys2virt_vi(dest);
 284         }
 285         else {
 286                 dest = here + icoord(dx, dy, 0);
 287                 return area->phys2virt_vi(dest);
 288         }
 289 }
 290
 291 // Python API.
 292 bool Entity::canMove(int x, int y, double z)
 293 {
 294         vicoord virt(x, y, z);
 295         return canMove(area->virt2phys(virt));
 296 }
 297
 298 bool Entity::canMove(icoord dest)
 299 {
 300         icoord dxyz = dest - getTileCoords_i();
 301         ivec2 dxy(dxyz.x, dxyz.y);
 302
 303         Tile* curTile = getTile();
 304         this->destTile = area->getTile(dest);
 305         this->destCoord = area->phys2virt_r(dest);
 306
 307         if ((curTile && curTile->exitAt(dxy)) ||
 308             (destTile && destTile->exits[EXIT_NORMAL])) {
 309                 // We can always take exits as long as we can take exits.
 310                 // (Even if they would cause us to be out of bounds.)
 311                 if (nowalkExempt & TILE_NOWALK_EXIT)
 312                         return true;
 313         }
 314
 315         bool inBounds = area->inBounds(dest);
 316         if (destTile && inBounds) {
 317                 // Tile is inside map. Can we move?
 318                 if (nowalked(*destTile))
 319                         return false;
 320                 if (destTile->entCnt)
 321                         // Space is occupied by another Entity.
 322                         return false;
 323
 324                 return true;
 325         }
 326
 327         // The tile is legitimately off the map.
 328         return nowalkExempt & TILE_NOWALK_AREA_BOUND;
 329 }
 330
 331 bool Entity::canMove(vicoord dest)
 332 {
 333         return canMove(area->virt2phys(dest));
 334 }
 335
 336 bool Entity::isMoving() const
 337 {
 338         return moving || stillMoving;
 339 }
 340
 341 void Entity::moveByTile(int x, int y)
 342 {
 343         moveByTile(ivec2(x, y));
 344 }
 345
 346 void Entity::moveByTile(ivec2 delta)
 347 {
 348         if (moving)
 349                 return;
 350         setFacing(delta);
 351
 352         if (canMove(moveDest(facing)))
 353                 preMove();
 354         else
 355                 setPhase(directionStr(facing));
 356 }
 357
 358 void Entity::move(int, int)
 359 {
 360         throw "pure virtual function";
 361 }
 362
 363 Area* Entity::getArea()
 364 {
 365         return area;
 366 }
 367
 368 void Entity::setArea(Area* a)
 369 {
 370         leaveTile();
 371         area = a;
 372         calcDraw();
 373         setSpeed(speedMul); // Calculate new speed based on tile size.
 374         enterTile();
 375 }
 376
 377 double Entity::getSpeed() const
 378 {
 379         return speedMul;
 380 }
 381
 382 void Entity::setSpeed(double multiplier)
 383 {
 384         speedMul = multiplier;
 385         if (area) {
 386                 double tilesPerSecond = area->getTileDimensions().x / 1000.0;
 387                 speed = baseSpeed * speedMul * tilesPerSecond;
 388         }
 389 }
 390
 391 Tile* Entity::getTile() const
 392 {
 393         return area ? area->getTile(r) : NULL;
 394 }
 395
 396 Tile* Entity::getTile()
 397 {
 398         return area ? area->getTile(r) : NULL;
 399 }
 400
 401 void Entity::setFrozen(bool b)
 402 {
 403         frozen = b;
 404 }
 405
 406 bool Entity::getFrozen()
 407 {
 408         return frozen;
 409 }
 410
 411 FlagManip Entity::exemptManip()
 412 {
 413         return FlagManip(&nowalkExempt);
 414 }
 415
 416 void Entity::erase()
 417 {
 418         throw "pure virtual function";
 419 }
 420
 421 void Entity::calcDraw()
 422 {
 423         ivec2 tile = area->getTileDimensions();
 424
 425         // X-axis is centered on tile.
 426         doff.x = (tile.x - imgsz.x) / 2;
 427         // Y-axis is aligned with bottom of tile.
 428         doff.y = tile.y - imgsz.y;
 429 }
 430
 431 SampleRef Entity::getSound(const std::string& name) const
 432 {
 433         SampleMap::const_iterator it;
 434         it = sounds.find(name);
 435         if (it != sounds.end())
 436                 return it->second;
 437         else
 438                 return SampleRef();
 439 }
 440
 441 ivec2 Entity::setFacing(ivec2 facing)
 442 {
 443         this->facing = ivec2(
 444                 Gosu::clamp(facing.x, -1, 1),
 445                 Gosu::clamp(facing.y, -1, 1)
 446         );
 447         return this->facing;
 448 }
 449
 450 const std::string& Entity::directionStr(ivec2 facing) const
 451 {
 452         return directions[facing.y+1][facing.x+1];
 453 }
 454
 455 enum SetPhaseResult Entity::_setPhase(const std::string& name)
 456 {
 457         AnimationMap::iterator it;
 458         it = phases.find(name);
 459         if (it == phases.end()) {
 460                 return PHASE_NOTFOUND;
 461         }
 462         Animation* newPhase = &it->second;
 463         if (phase != newPhase) {
 464                 time_t now = World::instance()->time();
 465                 phase = newPhase;
 466                 phase->startOver(now, ANIM_INFINITE_CYCLES);
 467                 phaseName = name;
 468                 redraw = true;
 469                 return PHASE_CHANGED;
 470         }
 471         return PHASE_NOTCHANGED;
 472 }
 473
 474 bool Entity::nowalked(Tile& t)
 475 {
 476         unsigned flags = nowalkFlags & ~nowalkExempt;
 477         return t.hasFlag(flags);
 478 }
 479
 480 void Entity::preMove()
 481 {
 482         fromCoord = r;
 483         fromTile = getTile();
 484
 485         rcoord d = destCoord - fromCoord;
 486         deltaCoord = area->virt2virt(d);
 487
 488         moving = true;
 489
 490         // Start moving animation.
 491         switch (conf.moveMode) {
 492         case TURN:
 493                 break;
 494         case TILE:
 495         case NOTILE:
 496                 setPhase("moving " + getFacing());
 497                 break;
 498         }
 499
 500         // Process triggers.
 501         runTileExitScript();
 502         if (fromTile)
 503                 fromTile->runLeaveScript(this);
 504
 505         // Modify tile's entity count.
 506         leaveTile();
 507         enterTile(destTile);
 508
 509         SampleRef step = getSound("step");
 510         if (step)
 511                 step->play();
 512
 513         // Set z right away so that we're on-level with the square we're
 514         // entering.
 515         r.z = destCoord.z;
 516
 517         if (conf.moveMode == TURN) {
 518                 // Movement is instantaneous.
 519                 redraw = true;
 520                 r = destCoord;
 521                 postMove();
 522         }
 523         else {
 524                 // Movement happens over time. See tickTile().
 525         }
 526 }
 527
 528 void Entity::postMove()
 529 {
 530         moving = false;
 531
 532         if (destTile) {
 533                 double* layermod = destTile->layermods[EXIT_NORMAL];
 534                 if (layermod)
 535                         r.z = *layermod;
 536         }
 537
 538         // Stop moving animation.
 539         if (!stillMoving)
 540                 setPhase(getFacing());
 541
 542         // Process triggers.
 543         if (destTile)
 544                 destTile->runEnterScript(this);
 545
 546         runTileEntryScript();
 547
 548         // TODO: move teleportation here
 549         /*
 550          * if (onExit()) {
 551          *      leaveTile();
 552          *      moveArea(getExit());
 553          *      postMoveScript();
 554          *      enterTile();
 555          * }
 556          */
 557 }
 558
 559 void Entity::leaveTile()
 560 {
 561         Tile* t = getTile();
 562         if (t)
 563                 t->entCnt--;
 564 }
 565
 566 void Entity::enterTile()
 567 {
 568         Tile* t = getTile();
 569         if (t)
 570                 enterTile(getTile());
 571 }
 572
 573 void Entity::enterTile(Tile* t)
 574 {
 575         if (t)
 576                 t->entCnt++;
 577 }
 578
 579 void Entity::runTickScript()
 580 {
 581         if (!tickScript)
 582                 return;
 583         pythonSetGlobal("Area", area);
 584         pythonSetGlobal("Entity", this);
 585         pythonSetGlobal("Tile", getTile());
 586         tickScript->invoke();
 587 }
 588
 589 void Entity::runTurnScript()
 590 {
 591         if (!turnScript)
 592                 return;
 593         pythonSetGlobal("Area", area);
 594         pythonSetGlobal("Entity", this);
 595         pythonSetGlobal("Tile", getTile());
 596         turnScript->invoke();
 597 }
 598
 599 void Entity::runTileExitScript()
 600 {
 601         if (!tileExitScript)
 602                 return;
 603         pythonSetGlobal("Area", area);
 604         pythonSetGlobal("Entity", this);
 605         pythonSetGlobal("Tile", getTile());
 606         tileExitScript->invoke();
 607 }
 608
 609 void Entity::runTileEntryScript()
 610 {
 611         if (!tileEntryScript)
 612                 return;
 613         pythonSetGlobal("Area", area);
 614         pythonSetGlobal("Entity", this);
 615         pythonSetGlobal("Tile", getTile());
 616         tileEntryScript->invoke();
 617 }
 618
 619
 620 /*
 621  * DESCRIPTOR CODE BELOW
 622  */
 623
 624 bool Entity::processDescriptor()
 625 {
 626         XMLRef doc = Reader::getXMLDoc(descriptor, "dtd/entity.dtd");
 627         if (!doc)
 628                 return false;
 629         const XMLNode root = doc->root(); // <entity>
 630         if (!root)
 631                 return false;
 632
 633         for (XMLNode node = root.childrenNode(); node; node = node.next()) {
 634                 if (node.is("speed")) {
 635                         ASSERT(node.doubleContent(&baseSpeed));
 636                         setSpeed(speedMul); // Calculate speed from tile size.
 637                 } else if (node.is("sprite")) {
 638                         ASSERT(processSprite(node.childrenNode()));
 639                 } else if (node.is("sounds")) {
 640                         ASSERT(processSounds(node.childrenNode()));
 641                 } else if (node.is("scripts")) {
 642                         ASSERT(processScripts(node.childrenNode()));
 643                 }
 644         }
 645         return true;
 646 }
 647
 648 bool Entity::processSprite(XMLNode node)
 649 {
 650         TiledImageRef tiles;
 651         for (; node; node = node.next()) {
 652                 if (node.is("sheet")) {
 653                         std::string imageSheet = node.content();
 654                         ASSERT(node.intAttr("tile_width",  &imgsz.x) &&
 655                                node.intAttr("tile_height", &imgsz.y));
 656                         tiles = Reader::getTiledImage(imageSheet, imgsz.x, imgsz.y);
 657                         ASSERT(tiles);
 658                 } else if (node.is("phases")) {
 659                         ASSERT(processPhases(node.childrenNode(), tiles));
 660                 }
 661         }
 662         return true;
 663 }
 664
 665 bool Entity::processPhases(XMLNode node, const TiledImageRef& tiles)
 666 {
 667         for (; node; node = node.next())
 668                 if (node.is("phase"))
 669                         ASSERT(processPhase(node, tiles));
 670         return true;
 671 }
 672
 673 bool Entity::processPhase(const XMLNode node, const TiledImageRef& tiles)
 674 {
 675         /* Each phase requires a 'name' and 'frames'. Additionally,
 676          * 'speed' is required if 'frames' has more than one member.
 677          */
 678         const std::string name = node.attr("name");
 679         if (name.empty()) {
 680                 Log::err(descriptor, "<phase> name attribute is empty");
 681                 return false;
 682         }
 683
 684         const std::string framesStr = node.attr("frames");
 685         const std::string speedStr = node.attr("speed");
 686
 687         if (framesStr.empty()) {
 688                 Log::err(descriptor, "<phase> frames attribute empty");
 689                 return false;
 690         }
 691
 692         if (isInteger(framesStr)) {
 693                 int frame = atoi(framesStr.c_str());
 694                 if (frame < 0 || (int)tiles->size() < frame) {
 695                         Log::err(descriptor,
 696                                 "<phase> frames attribute index out of bounds");
 697                         return false;
 698                 }
 699                 const ImageRef& image = (*tiles.get())[frame];
 700                 phases[name] = Animation(image);
 701         }
 702         else if (isRanges(framesStr)) {
 703                 if (!isDecimal(speedStr)) {
 704                         Log::err(descriptor,
 705                                 "<phase> speed attribute must be present and "
 706                                 "must be decimal");
 707                 }
 708                 double fps = atof(speedStr.c_str());
 709
 710                 typedef std::vector<int> IntVector;
 711                 IntVector frames = parseRanges(framesStr);
 712                 std::vector<ImageRef> images;
 713                 for (IntVector::iterator it = frames.begin(); it != frames.end(); it++) {
 714                         int i = *it;
 715                         if (i < 0 || (int)tiles->size() < i) {
 716                                 Log::err(descriptor,
 717                                         "<phase> frames attribute index out of bounds");
 718                                 return false;
 719                         }
 720                         images.push_back((*tiles.get())[i]);
 721                 }
 722
 723                 phases[name] = Animation(images, (time_t)(1000.0 / fps));
 724         }
 725         else {
 726                 Log::err(descriptor,
 727                         "<phase> frames attribute not an int or int ranges");
 728                 return false;
 729         }
 730
 731         return true;
 732 }
 733
 734 bool Entity::processSounds(XMLNode node)
 735 {
 736         for (; node; node = node.next())
 737                 if (node.is("sound"))
 738                         ASSERT(processSound(node));
 739         return true;
 740 }
 741
 742 bool Entity::processSound(const XMLNode node)
 743 {
 744         const std::string name = node.attr("name");
 745         const std::string filename = node.content();
 746         if (name.empty()) {
 747                 Log::err(descriptor, "<sound> name attribute is empty");
 748                 return false;
 749         } else if (filename.empty()) {
 750                 Log::err(descriptor, "<sound></sound> is empty");
 751                 return false;
 752         }
 753
 754         SampleRef s = Reader::getSample(filename);
 755         if (s)
 756                 sounds[name] = s;
 757         return true;
 758 }
 759
 760 bool Entity::processScripts(XMLNode node)
 761 {
 762         for (; node; node = node.next())
 763                 if (node.is("script"))
 764                         ASSERT(processScript(node));
 765         return true;
 766 }
 767
 768 bool Entity::processScript(const XMLNode node)
 769 {
 770         const std::string trigger = node.attr("trigger");
 771         const std::string filename = node.content();
 772         if (trigger.empty()) {
 773                 Log::err(descriptor, "<script> trigger attribute is empty");
 774                 return false;
 775         } else if (filename.empty()) {
 776                 Log::err(descriptor, "<script></script> is empty");
 777                 return false;
 778         }
 779
 780         ScriptRef script = Script::create(filename);
 781         if (!script || !script->validate())
 782                 return false;
 783
 784         if (!setScript(trigger, script)) {
 785                 Log::err(descriptor,
 786                         "unrecognized script trigger: " + trigger);
 787                 return false;
 788         }
 789
 790         return true;
 791 }
 792
 793 bool Entity::setScript(const std::string& trigger, ScriptRef& script)
 794 {
 795         if (boost::iequals(trigger, "on_tick")) {
 796                 tickScript = script;
 797                 return true;
 798         }
 799         if (boost::iequals(trigger, "on_turn")) {
 800                 turnScript = script;
 801                 return true;
 802         }
 803         if (boost::equals(trigger, "on_tile_entry")) {
 804                 tileEntryScript = script;
 805                 return true;
 806         }
 807         if (boost::iequals(trigger, "on_tile_exit")) {
 808                 tileExitScript = script;
 809                 return true;
 810         }
 811         if (boost::iequals(trigger, "on_delete")) {
 812                 deleteScript = script;
 813                 return true;
 814         }
 815         return false;
 816 }
 817
 818
 819 void exportEntity()
 820 {
 821         using namespace boost::python;
 822
 823         class_<Entity>("Entity", no_init)
 824                 .def("init", &Entity::init)
 825                 .def("delete", &Entity::destroy)
 826                 .add_property("frozen", &Entity::getFrozen, &Entity::setFrozen)
 827                 .add_property("phase", &Entity::getPhase, &Entity::setPhase)
 828                 .add_property("area",
 829                     make_function(&Entity::getArea,
 830                       return_value_policy<reference_existing_object>()),
 831                     &Entity::setArea)
 832                 .add_property("tile", make_function(
 833                     static_cast<Tile* (Entity::*) ()> (&Entity::getTile),
 834                     return_value_policy<reference_existing_object>()))
 835                 .add_property("speed", &Entity::getSpeed, &Entity::setSpeed)
 836                 .add_property("moving", &Entity::isMoving)
 837                 .add_property("exempt", &Entity::exemptManip)
 838                 .add_property("coords", &Entity::getTileCoords_vi)
 839                 .def("set_coords",
 840                     static_cast<void (Entity::*) (int,int,double)>
 841                       (&Entity::setTileCoords))
 842                 .def("teleport", &Entity::teleport)
 843                 .def("move", &Entity::move)
 844                 .def("move_dest",
 845                     static_cast<vicoord (Entity::*) (Tile*,int,int)>
 846                       (&Entity::moveDest))
 847                 .def("can_move",
 848                     static_cast<bool (Entity::*) (int,int,double)>
 849                       (&Entity::canMove))
 850 //              .def_readwrite("on_tick", &Entity::tickScript)
 851 //              .def_readwrite("on_turn", &Entity::turnScript)
 852 //              .def_readwrite("on_tile_entry", &Entity::tileEntryScript)
 853 //              .def_readwrite("on_tile_exit", &Entity::tileExitScript)
 854 //              .def_readwrite("on_delete", &Entity::deleteScript)
 855                 ;
 856 }
 857