/************************************************************************
* Copyright (c) 2005-2007 tok@openlinux.org.uk                          *
*                                                                       *
* This software is provided as-is, without any express or implied       *
* warranty. In no event will the authors be held liable for any         *
* damages arising from the use of this software.                        *
*                                                                       *
* Permission is granted to anyone to use this software for any purpose, *
* including commercial applications, and to alter it and redistribute   *
* it freely, subject to the following restrictions:                     *
*                                                                       *
* 1. The origin of this software must not be misrepresented; you must   *
* not claim that you wrote the original software. If you use this       *
* software in a product, an acknowledgment in the product documentation *
* would be appreciated but is not required.                             *
*                                                                       *
* 2. Altered source versions must be plainly marked as such, and must   *
* not be misrepresented as being the original software.                 *
*                                                                       *
* 3. This notice may not be removed or altered from any source          *
* distribution.                                                         *
************************************************************************/
#include "game_objects.h"
#include "spritemanager.h"
#include "dataholder.h"
#include "cell_iterator.h"
#include "timer.h"
#include "Functor.h"

#define INT2FLOAT_WRLD(c) (float(c >> 6) + float(c % 64) / 64.0f)
#define INT2F_DIV64(v) (float(v) / 64.0f)
#define INT2F_DIV128(v) (float(v) / 128.0f)

float slope_height_offset(unsigned char slope_type, float dx, float dz);

namespace OpenGTA {
  float GameObject_common::heightOverTerrain(const Vector3D & v) {
    float x, y, z;
    x = floor(v.x);
    y = floor(v.y);
    z = floor(v.z);
    PHYSFS_uint8 x_b, z_b;
    x_b = (PHYSFS_uint8)x;
    z_b = (PHYSFS_uint8)z;
    if (y < 0.0f) {
      //ERROR << "Below level! at coords: " << v.x << ", " << v.y << ", " << v.z << std::endl;
      return 1.0f;
    }
    if (x < 0 || x > 255 || z < 0 || z > 255) {
      //ERROR << "x = " << x << "(" << v.x << ") z = " << z << " (" << v.z << ")" << std::endl;
      throw E_OUTOFRANGE("invalid x/z pos");
    }
    if (y > 20) {
      INFO << y << " seems a bit high; going to 20" << std::endl;
      INFO << x << " " << z << std::endl;
      y = 20;
    }
    OpenGTA::Map & map = OpenGTA::MapHolder::Instance().get();
    while (y >= map.getNumBlocksAtNew(x_b, z_b) && y > 0.0f)
      y -= 1.0f;
    while (y < map.getNumBlocksAtNew(x_b, z_b) && y > 0.0f) {
      OpenGTA::Map::BlockInfo * block = map.getBlockAtNew(x_b, z_b, (PHYSFS_uint8)y);
      assert(block);
      if (block->blockType() > 0) {
        float bz = slope_height_offset(block->slopeType(), v.x - x, v.z - z);
        if (block->slopeType() == 0 && block->blockType() != 5)
          bz -= 1.0f;
        return v.y - (y + bz);
      }
      y -= 1.0f;
    }
    y = floor(v.y) + 1.0f;
    while (y < map.getNumBlocksAtNew(x_b, z_b) && y > 0.0f) {
      OpenGTA::Map::BlockInfo * block = map.getBlockAtNew(x_b, z_b, (PHYSFS_uint8)y);
      assert(block);
      if (block->blockType() > 0) {
        float bz = slope_height_offset(block->slopeType(), v.x - x, v.z - z);
        if (block->slopeType() == 0 && block->blockType() != 5)
          bz -= 1.0f;
        return v.y - (y + bz);
      }
      y += 1.0f;
    }
    INFO << "should this be reached?" << std::endl;
    return 1.0f;
  }

  Sprite::Animation::Animation() :
    Util::Animation(7, 7),
    firstFrameOffset(0), moveSpeed(0.0f) {}

  Sprite::Animation::Animation(const Animation & other) :
    //Util::Animation(other.numFrames, 1000 / other.delay),
    Util::Animation(other),
    firstFrameOffset(other.firstFrameOffset), 
    //numFrames(other.numFrames),
    moveSpeed(other.moveSpeed) {
      set(other.get(), other.getDone());
    }

  Sprite::Animation::Animation(Uint16 foff, Uint8 num) :
    Util::Animation(num, 7),
    firstFrameOffset(foff), moveSpeed(0.0f) {}

  Sprite::Animation::Animation(Uint16 foff, Uint8 num, float speed) :
    Util::Animation(num, 7),
    firstFrameOffset(foff), moveSpeed(speed) {}

  Sprite::Sprite() :
    sprNum(0), remap(-1), 
    //anim(SpriteManagerHolder::Instance().getAnimationById(0)),
    anim(), animId(),
    sprType(GraphicsBase::SpriteNumbers::ARROW) {
    }

  Sprite::Sprite(Uint16 sprN, Sint16 rem, GraphicsBase::SpriteNumbers::SpriteTypes sprT) :
    sprNum(sprN), remap(rem),
    anim(), animId(),
    sprType(sprT) {}

  Sprite::Sprite(const Sprite & other) :
    sprNum(other.sprNum), remap(other.remap), anim(other.anim), animId(other.animId),
    sprType(other.sprType) {
    }

  void Sprite::switchToAnim(const Uint32 & newId) {
    INFO << "switching to anim " << newId << std::endl;
    anim = Animation(SpriteManagerHolder::Instance().getAnimationById(newId));
    anim.set(Util::Animation::PLAY_FORWARD, Util::Animation::LOOP);
    animId = newId;
  }

  Pedestrian::Pedestrian(Vector3D e, const Vector3D & p, uint32_t id, Sint16 remapId) :
    GameObject_common(p), 
    Sprite(0, remapId, GraphicsBase::SpriteNumbers::PED), 
    OBox(TranslateMatrix3D(p), e * 0.5f),
    m_control(),
    speedForces(0, 0, 0) {
      m_M = TranslateMatrix3D(p);
      m_M.RotZ(rot);
      pedId = id;
      animId = 0;
      isDead = 0;
      lastUpdateAt = TimerHolder::Instance().getRealTime();
      inGroundContact = 0;
    }

  Pedestrian::Pedestrian(const Pedestrian & other) :
    GameObject_common(other), Sprite(other), OBox(other),

    pedId(other.pedId),
    m_control(),
    speedForces(other.speedForces) {
      lastUpdateAt = other.lastUpdateAt; 
      inGroundContact = other.inGroundContact;
      animId = other.animId;
      isDead = other.isDead;
      m_M = TranslateMatrix3D(other.pos);
      m_M.RotZ(other.rot);
    }

  extern void ai_step_fake(Pedestrian*);
  void Pedestrian::update(Uint32 ticks) {
    if (isDead) {
      anim.update(ticks);
      lastUpdateAt = ticks;
      return;
    }
    if (pedId < 0xffffffff)
      ai_step_fake(this);
    uint8_t activeWeapon = m_control.getActiveWeapon(); 
    switch(m_control.getMove()) {
      case 1:
        //if (!(animId == 2u + activeWeapon*3))
        //  switchToAnim(2 + activeWeapon*3);
        if (m_control.getRunning()) {
          if (!(animId == 3u + activeWeapon*3))
            switchToAnim(3 + activeWeapon*3);
        }
        else {
          if (!(animId == 2u + activeWeapon*2))
            switchToAnim(2 + activeWeapon*2);
        }
        break;
        /*
      case 2:
        if (!(animId == 3u + activeWeapon*3))
          switchToAnim(3 + activeWeapon*3);
        break;
        */
      case 0:
        if (!(animId == 1u + activeWeapon*3))
          switchToAnim(1 + activeWeapon*3);
        break;
      case -1:
        if (!(animId == 2u + activeWeapon*3)) {
          switchToAnim(2 + activeWeapon*3);
          anim.set(Util::Animation::PLAY_BACKWARD, Util::Animation::LOOP);
        }
    }
    anim.update(ticks);
    Uint32 delta = ticks - lastUpdateAt;
    //INFO << "delta = " << delta  << " t: " << ticks << " lt: " << lastUpdateAt << std::endl;
    Vector3D moveDelta(0, 0, 0);
    switch(m_control.getTurn()) {
      case -1:
        rot -= 0.2f * delta;
        //INFO << "rot: "<< rot << std::endl;
        break;
      case 1:
        rot += 0.2f * delta;
        //INFO << "rot: "<< rot << std::endl;
        break;
      case 0:
        break;
    }
    if (rot >= 360.0f)
      rot -= 360.0f;
    if (rot < 0.0f)
      rot += 360.0f;
    switch(m_control.getMove()) {
      case -1:
        moveDelta.x -= sin(rot * M_PI / 180.0f) * anim.moveSpeed * delta;
        moveDelta.z -= cos(rot * M_PI / 180.0f) * anim.moveSpeed * delta;
        break;
      case 1:
        moveDelta.x += sin(rot * M_PI / 180.0f) * anim.moveSpeed * delta;
        moveDelta.z += cos(rot * M_PI / 180.0f) * anim.moveSpeed * delta;
        break;
      case 2:
        moveDelta.x += sin(rot * M_PI / 180.0f) * anim.moveSpeed * delta;
        moveDelta.z += cos(rot * M_PI / 180.0f) * anim.moveSpeed * delta;
        break;
      case 0:
        break;
    }
    tryMove(pos + moveDelta);
    if (!inGroundContact) {
      speedForces.y += 0.0005f *delta;
      pos.y -= speedForces.y;
      if (speedForces.y < 0.2f)
        INFO << "bridge step? height: " << pos.y << " speed: " << speedForces.y << std::endl;
      else
        INFO << "FALLING " << pos.y << " speed " << speedForces.y << std::endl;
    }
    else {
      if (speedForces.y > 0.1)
        INFO << "impacting with speed: " << speedForces.y << std::endl;
      speedForces.y = 0.0f;
    }
    m_M = TranslateMatrix3D(pos);
    m_M.RotZ(rot);
    if (m_control.getFireWeapon() && ticks - lastWeaponTick > 400) {
      Vector3D d1(
        //Vector3D(-cos(rot * M_PI/180.0f), 0, sin(rot * M_PI/180.0f)).Normalized() * 0.05f 
        Vector3D(sin(rot * M_PI/180.0f), 0, cos(rot * M_PI/180.0f)).Normalized() * 0.01f 
      ); 
      SpriteManagerHolder::Instance().createProjectile(0, rot, pos, d1, ticks, pedId);
      lastWeaponTick = ticks;
    }
    //INFO << pos.x << " " << pos.y << " " << pos.z << std::endl;
    lastUpdateAt = ticks;
  }

   void Pedestrian::tryMove(Vector3D nPos) {
    float x, y, z;
    x = floor(nPos.x);
    y = floor(nPos.y);
    z = floor(nPos.z);
    OpenGTA::Map & map = OpenGTA::MapHolder::Instance().get();
    OpenGTA::GraphicsBase & graphics = OpenGTA::StyleHolder::Instance().get();
    //INFO << heightOverTerrain(nPos) << std::endl;
    float hot = heightOverTerrain(nPos);
    if (hot > 0.1f)
      inGroundContact = 0;
    else if (hot < 0.0) {
      INFO << "gone below: " << hot << " at " << nPos.x << ", " << nPos.y << ", " << nPos.z << std::endl;
      nPos.y -= (hot - 0.3f);
      INFO << nPos.y << std::endl;
      inGroundContact = 1;
    }
    else {
      inGroundContact = 1;
      if (isDead)
        nPos.y -= hot - 0.05f;
      else
        nPos.y -= hot - 0.1f;
    }
    if (y < map.getNumBlocksAtNew(PHYSFS_uint8(x), PHYSFS_uint8(z)) && y > 0.0f) {
      //INFO << x << ", " << y << ", " << z << ": " << int(map.getNumBlocksAtNew(PHYSFS_uint8(x), PHYSFS_uint8(z))) << std::endl;
      OpenGTA::Map::BlockInfo * block = map.getBlockAtNew(PHYSFS_uint8(x), PHYSFS_uint8(z), PHYSFS_uint8(y));
      assert(block);/*
      if (block->blockType() > 0) {
        float bz = slope_height_offset(block->slopeType(), nPos.x - x, nPos.z - z);
        if (block->slopeType() == 0)
          bz -= 1.0f;
        if (inGroundContact) {
          nPos.y = y + bz + 0.3f;
          //pos = nPos;
        }
        else if (nPos.y - y - bz < 0.3f) {
      INFO << "ped near ground (type: " << int(block->blockType()) << " float-pos: " 
        << nPos.x << ", " << nPos.y << ", " << nPos.z << std::endl;
          inGroundContact = 1;
          nPos.y = y + bz + 0.3f;
          INFO << "height rewritten to: " << nPos.y << std::endl;
          //pos = nPos;
          
        }
      }
      else {
        inGroundContact = 0;
        INFO << "lost footing: " << x << ", " << y << ", " << z << std::endl;
      }*/
      if (block->left && graphics.isBlockingSide(block->left)) { // && block->isFlat() == false) {
        if (block->isFlat()) {
        //INFO << "xblock left: " << x - pos.x << std::endl;
          if (x - pos.x < 0 && x - pos.x > -0.2f) {
            nPos.x = (nPos.x < pos.x) ? pos.x : nPos.x;
          }
          else if (x - pos.x > 0 && x - pos.x < 0.2f)
            nPos.x = pos.x;
        }
        else {
#ifdef DEBUG_OLD_PED_BLOCK
        INFO << "xblock left: " << x - pos.x << " tex: " << int(block->left) << std::endl;
#endif
          if (x - pos.x > 0 && x - pos.x < 0.2f)
            nPos.x = pos.x;
          else if (x - pos.x < 0 && x - pos.x > -0.2f)
            nPos.x = (nPos.x < pos.x) ? pos.x : nPos.x;
        }
      }
      if (block->right && block->isFlat() == false) {
#ifdef DEBUG_OLD_PED_BLOCK
        INFO << "xblock right: " << pos.x - x - 1 << " tex: " << int(block->right) << std::endl;
#endif
        if (pos.x - x - 1 > 0 && pos.x - x - 1 < 0.2f) {
          nPos.x = pos.x;
        }
        else if (pos.x - x - 1 < 0 && pos.x - x - 1 > -0.2f)
          nPos.x = (nPos.x > pos.x) ? pos.x : nPos.x;
      }
      if (block->top && graphics.isBlockingSide(block->top)) { // && block->isFlat() == false) {
        if (block->isFlat()) {
#ifdef DEBUG_OLD_PED_BLOCK
        INFO << "zblock top: " << z - pos.z << " tex: " << int(block->top) << std::endl;
#endif
          if (z - pos.z > 0 && z - pos.z < 0.2f)
            nPos.z = pos.z;
          else if (z - pos.z < 0 && z - pos.z > -0.2f)
            nPos.z = (nPos.z < pos.z) ? pos.z : nPos.z;
        }
        else {
#ifdef DEBUG_OLD_PED_BLOCK
        INFO << "zblock top: " << z - pos.z << " tex: " << int(block->top)<<  std::endl;
#endif
          if (z - pos.z > 0 && z - pos.z < 0.2f)
            nPos.z = pos.z;
          else if (z - pos.z < 0 && z - pos.z > -0.2f)
            nPos.z = (nPos.z < pos.z) ? pos.z : nPos.z;
        }
      }
      if (block->bottom && block->isFlat() == false) {
#ifdef DEBUG_OLD_PED_BLOCK
        INFO << "zblock bottom: " << pos.z - z - 1<< " tex: " << int(block->bottom)<< std::endl;
#endif
        if (pos.z - z - 1 > 0 && pos.z - z - 1 < 0.2f) {
          nPos.z = pos.z;
        }
        else if (pos.z - z - 1 < 0 && pos.z - z - 1 > -0.2f)
          nPos.z = (nPos.z > pos.z) ? pos.z : nPos.z;
      }
      if (x >= 1 && y < map.getNumBlocksAtNew(PHYSFS_uint8(x-1), PHYSFS_uint8(z))) {
        block = map.getBlockAtNew(PHYSFS_uint8(x-1), PHYSFS_uint8(z), PHYSFS_uint8(y));
        if (block->right && block->isFlat() == false) {
#ifdef DEBUG_OLD_PED_BLOCK
          INFO << "xblock right: " << pos.x - x << " tex: " << int(block->right)<< std::endl;
#endif
          if (pos.x - x < 0.2f) {
            nPos.x = (nPos.x < pos.x ? pos.x : nPos.x);
          }
        }
      }
      if (x < 255 && y < map.getNumBlocksAtNew(PHYSFS_uint8(x+1), PHYSFS_uint8(z))) {
        block = map.getBlockAtNew(PHYSFS_uint8(x+1), PHYSFS_uint8(z), PHYSFS_uint8(y));
        if (block->left && graphics.isBlockingSide(block->left)) { // && block->isFlat() == false) {
#ifdef DEBUG_OLD_PED_BLOCK
          INFO << "xblock left: " << x + 1 - pos.x << " tex: " << int(block->left)<< std::endl;
#endif
          if (block->isFlat()) {
            if (x + 1 - pos.x > 0 && x + 1 - pos.x < 0.2f)
              nPos.x = (nPos.x < pos.x ? nPos.x : pos.x);
          }
          else {
            if (x + 1 - pos.x < 0.2f)
              nPos.x = (nPos.x < pos.x ? nPos.x : pos.x);
          }
        }
      }
      if (z >= 1 && y < map.getNumBlocksAtNew(PHYSFS_uint8(x), PHYSFS_uint8(z-1))) {
        block = map.getBlockAtNew(PHYSFS_uint8(x), PHYSFS_uint8(z-1), PHYSFS_uint8(y));
        if (block->bottom && block->isFlat() == false) {
#ifdef DEBUG_OLD_PED_BLOCK
          INFO << "zblock bottom: " << pos.z - z<< " tex: " << int(block->bottom)<< std::endl;
#endif
          if (pos.z - z < 0.2f) {
            nPos.z = (nPos.z < pos.z ? pos.z : nPos.z);
          }
        }
      }
      if (z < 255 && y < map.getNumBlocksAtNew(PHYSFS_uint8(x), PHYSFS_uint8(z+1))) {
        block = map.getBlockAtNew(PHYSFS_uint8(x), PHYSFS_uint8(z+1), PHYSFS_uint8(y));
        if (block->top && graphics.isBlockingSide(block->top)) { // && block->isFlat() == false) {
#ifdef DEBUG_OLD_PED_BLOCK
          INFO << "zblock top: " << z + 1 - pos.z<< " tex: " << int(block->top) << std::endl;
#endif
          if (block->isFlat()) {
            if (z + 1 - pos.z > 0 && z + 1 - pos.z < 0.2f)
              nPos.z = (nPos.z < pos.z ? nPos.z : pos.z);
          }
          else {
            if (z + 1 - pos.z < 0.2f)
              nPos.z = (nPos.z < pos.z ? nPos.z : pos.z);
          }
        }
      }
      //if (inGroundContact)
      //  pos = nPos;
    }
    if (inGroundContact)
      pos = nPos;
    //else
    //  inGroundContact = 0;

  }

  void Pedestrian::die() {
    INFO << "DIE!!!" << std::endl; 
    switchToAnim(42);
  }

  void Pedestrian::getShot(bool front) {
    isDead = 1;
    switchToAnim(45);
    anim.set(Util::Animation::PLAY_FORWARD, Util::Animation::FCALLBACK);
    Loki::Functor<void> cmd(this, &Pedestrian::die);
    anim.setCallback(cmd);
  }

  Car::Car(OpenGTA::Map::ObjectPosition& op, uint32_t id) :
    GameObject_common(Vector3D(INT2FLOAT_WRLD(op.x), 6.05f-INT2FLOAT_WRLD(op.z), INT2FLOAT_WRLD(op.y))),
    Sprite(0, -1, GraphicsBase::SpriteNumbers::CAR), OBox(),
    carInfo(*StyleHolder::Instance().get().findCarByModel(op.type)){
    carId = id;
    type = op.type;
    sprNum = carInfo.sprNum;
    m_Extent = Vector3D(INT2F_DIV128(carInfo.width),
      INT2F_DIV128(carInfo.depth),
      INT2F_DIV128(carInfo.height));
    m_M = TranslateMatrix3D(pos);
    m_M.RotZ(rot);

    rot = op.rotation * 360 / 1024;
  }

  Car::Car(const Car & other) :
    GameObject_common(other), Sprite(other), OBox(other),
    carInfo(*StyleHolder::Instance().get().findCarByModel(other.type)) {
    type = other.type;
    m_M = TranslateMatrix3D(pos);
    m_M.RotZ(rot);

    carId = other.carId;
  }

  void Car::update(Uint32 ticks) {
  }

  SpriteObject::SpriteObject(OpenGTA::Map::ObjectPosition& op, uint32_t id) :
    GameObject_common(Vector3D(INT2FLOAT_WRLD(op.x), 6.05f-INT2FLOAT_WRLD(op.z), INT2FLOAT_WRLD(op.y))),
    Sprite(0, -1, GraphicsBase::SpriteNumbers::OBJECT), OBox() {
    objId = id;
    GraphicsBase & style = StyleHolder::Instance().get();
    sprNum = style.objectInfos[op.type]->sprNum;
    m_Extent = Vector3D(INT2F_DIV128(style.objectInfos[op.type]->width),
      INT2F_DIV128(style.objectInfos[op.type]->depth),
      INT2F_DIV128(style.objectInfos[op.type]->height));
    m_M = TranslateMatrix3D(pos);
    m_M.RotZ(rot);
    rot = op.rotation * 360 / 1024;
    isActive = true;
  }

  SpriteObject::SpriteObject(Vector3D pos, Uint16 sprNum, OpenGTA::GraphicsBase::SpriteNumbers::SpriteTypes sprT) :
    GameObject_common(pos), Sprite(sprNum, -1, sprT), OBox() {
    isActive = true;
    m_M = TranslateMatrix3D(pos);
    m_M.RotZ(rot);
  }

  SpriteObject::SpriteObject(const SpriteObject & other) :
    GameObject_common(other), Sprite(other), OBox(other),
    
    objId(other.objId) {
    m_M = TranslateMatrix3D(pos);
    m_M.RotZ(rot);

    isActive = other.isActive;
  }

  void SpriteObject::update(Uint32 ticks) {
    anim.update(ticks);
  }

  Projectile::Projectile(unsigned char t, float r, Vector3D p, Vector3D d, uint32_t ticks, uint32_t o) :
    GameObject_common(p, r),
    typeId(t), delta(d), endsAtTick(ticks),
    owner(o), lastUpdateAt(ticks) {
    endsAtTick = lastUpdateAt + 1000;
  }

  Projectile::Projectile(const Projectile & other) :
    GameObject_common(other),
    typeId(other.typeId), delta(other.delta), endsAtTick(other.endsAtTick),
    owner(other.owner), lastUpdateAt(other.lastUpdateAt) {}

  void Projectile::update(uint32_t ticks) {
    Uint32 dt = ticks - lastUpdateAt;
    Vector3D new_pos(pos + delta * dt);
    /*INFO << "p-m " << pos.x << " " << pos.y << " " << pos.z << 
    " to " << new_pos.x << " " << new_pos.y << " " << new_pos.z << std::endl;
    */
    std::list<Pedestrian> & list = SpriteManagerHolder::Instance().getList<Pedestrian>();
    for (std::list<Pedestrian>::iterator i = list.begin(); i != list.end(); ++i) {
      Pedestrian & ped = *i;
      if (ped.id() == owner)
        continue;
      if (ped.isDead)
        continue;
      /*INFO << "ped " << ped.id() << " pos: " << ped.pos.x << " " << ped.pos.y << " " << ped.pos.z << std::endl;
      Vector3D p = ped.GetCenterPoint();
      INFO << "CP " << p.x << " " << p.y << " " << p.z << std::endl;
      p = ped.m_Extent;
      INFO << "extent " << p.x << " " << p.y << " " << p.z << std::endl;
      for (int i=0; i < 4; i++) {
        for (int j=0; j < 4; j++) {
          std::cout << "M " << ped.m_M.m[i][j] << " ";
        }
        std::cout << std::endl;
      }*/
        

      if (ped.IsLineInBox( pos, new_pos ) ) {
        INFO << "HIT ped " << ped.id() << std::endl;
        ped.getShot(true);
        //ped.sprType = GraphicsBase::SpriteNumbers::OBJECT;
        //ped.remap = -1;
        //SpriteManagerHolder::Instance().removePed(ped.pedId);
        endsAtTick = 0;
      }
    }
    
    /*
    Util::CellIterator oi(pos);

    Util::CellIterator ni(new_pos);
    //FIXME ni valid?
    
    if (oi.isValid() && ni.isValid()) {
      if (oi == ni) { // only one cell to check
        Math::line_intersect(pos, new_pos);//, oi.getBlock());
      }
      else { // crosses cell boundary
        Math::line_intersect(pos, new_pos);//, oi.getBlock());
        //Math::line_intersect(pos, new_pos);//, ni.getBlock());
      }
    }
    else
      INFO << "NEITHER VALID!"<< oi.x << " " << oi.y << " " << oi.z <<std::endl;
    */
    pos = new_pos; 

    lastUpdateAt = ticks;
  }
}