OpenGTA/pedestrian.cpp

/************************************************************************
* Copyright (c) 2005-2006 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 "pedestrian.h"
#include "spritemanager.h"
#include "opengta.h"
#include "dataholder.h"
#include "log.h"

float slope_height_offset(unsigned char slope_type, float dx, float dz);
namespace OpenGTA {
  Projectile::Projectile(uint8_t id, float r, Vector3D p, Vector3D d, Uint32 now) :
    typeId(id), rot(r), pos(p), delta(d), endsAtTick(now + 5000) {}

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

  SpriteObject::Animation::Animation(const Animation & other) :
    Util::Animation(other.numFrames, 1000 / other.delay),
    firstFrameOffset(other.firstFrameOffset), 
    //numFrames(other.numFrames),
    moveSpeed(other.moveSpeed) {}
  
  SpriteObject::Animation::Animation(Uint16 foff, Uint8 num) :
    Util::Animation(num, 7),
    firstFrameOffset(foff), moveSpeed(0.0f) {}

  SpriteObject::Animation::Animation(Uint16 foff, Uint8 num, float speed) :
    Util::Animation(num, 7),
    firstFrameOffset(foff), moveSpeed(speed) {}
  
  SpriteObject::SpriteObject(const Vector3D & p) :
    pos(p), //animRef(&SpriteManagerHolder::Instance().getAnimationById(0)) {
    anim(SpriteManagerHolder::Instance().getAnimationById(0)) {
    sprNum = 0;
    remap = -1;
    //curFrame = 0;
    lastFrameUpdateAt = 0;
    lastUpdateAt = 0;
    rot = 0.0f;
    animActive = false;
    sprType = GraphicsBase::SpriteNumbers::ARROW;
  }
  
  Uint8 SpriteObject::calcCurrentFrame(Uint32 ticks) {
    Uint32 delta = ticks - lastFrameUpdateAt;
    //assert(animRef);
    if (delta > 100) {
      //curFrame += 1;
      //INFO << "new frame: " << int(curFrame) << " total: " << sprNum + curFrame + anim.firstFrameOffset << std::endl;
      lastFrameUpdateAt = ticks;
    }
    /*
    if (curFrame > anim.numFrames)
      curFrame = 0;
    */
    return 0;//curFrame;
  }

  SpriteObject::SpriteObject(const SpriteObject & other) :
    pos(other.pos), anim(other.anim) {
    copyValues(other);
  }

  void SpriteObject::copyValues(const SpriteObject & other) {
    sprNum = other.sprNum;
    //curFrame = other.curFrame;
    remap = other.remap;
    lastFrameUpdateAt = other.lastFrameUpdateAt;
    lastUpdateAt = other.lastUpdateAt;
    rot = other.rot;
    sprType = other.sprType;
    animActive = other.animActive;
  }

  float SpriteObject::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;
    }
    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;
  }

  Pedestrian::Pedestrian(const Vector3D & e,
    const Vector3D & p) : SpriteObject(p), 
      OBox(RollMatrix3D(0), e * 0.5f) {
    m_M.Translate(p);
    pedId = 0;
    m_control = 0;
    animId = 0;
    inGroundContact = 0;
    sprType = GraphicsBase::SpriteNumbers::PED;
    activeWeapon = 0;
    speedForces = Vector3D(0, 0, 0);
    weaponReloadedAt = 0;
  }

  Pedestrian::Pedestrian(const Vector3D & e,
    const Vector3D & p, const Uint32 & asId) : SpriteObject(p),
      OBox(RollMatrix3D(0), e * 0.5f) {
    m_M.Translate(p);
    pedId = asId;
    m_control = 0;
    animId = 0;
    inGroundContact = 0;
    sprType = GraphicsBase::SpriteNumbers::PED;
    activeWeapon = 0;
    speedForces = Vector3D(0, 0, 0);
    weaponReloadedAt = 0;
  }

  Pedestrian::Pedestrian(const Pedestrian & other) : SpriteObject(other),
    OBox(other.m_M, other.m_Extent) {
    //animRef(SpriteManagerHolder::Instance().getAnimationById(other.animId)) { 
    copyValues(other);
  }

  void Pedestrian::switchToAnim(const Uint32 & newId) {
    anim = Animation(SpriteManagerHolder::Instance().getAnimationById(newId));
    anim.set(Util::Animation::PLAY_FORWARD, Util::Animation::LOOP);
    animId = newId;
    //curFrame = 0;
  }

  void SpriteObject::setAnimation(Animation & otherAnim) {
    anim = Animation(otherAnim);
    //curFrame = 0;
    // FIXME: animId?
  }

  void Pedestrian::copyValues(const Pedestrian & other) {

    m_control = other.m_control;
    animId = other.animId;
    pedId = other.pedId;
    inGroundContact = other.inGroundContact;
    sprType = other.sprType;
    speedForces = other.speedForces;
    activeWeapon = other.activeWeapon;
    inventory = other.inventory;
    weaponReloadedAt = other.weaponReloadedAt;
  }

  void Pedestrian::giveItem(uint8_t id, uint32_t amount) {
    InventoryType::iterator i = inventory.find(id);
    if (i == inventory.end())
      inventory[id] = amount;
    else
      i->second += amount;
  }

  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.3f)
      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 (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 {
        INFO << "xblock left: " << x - pos.x << " tex: " << int(block->left) << std::endl;
          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) {
        INFO << "xblock right: " << pos.x - x - 1 << " tex: " << int(block->right) << std::endl;
        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()) {
        INFO << "zblock top: " << z - pos.z << " tex: " << int(block->top) << std::endl;
          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 {
        INFO << "zblock top: " << z - pos.z << " tex: " << int(block->top)<<  std::endl;
          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) {
        INFO << "zblock bottom: " << pos.z - z - 1<< " tex: " << int(block->bottom)<< std::endl;
        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) {
          INFO << "xblock right: " << pos.x - x << " tex: " << int(block->right)<< std::endl;
          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) {
          INFO << "xblock left: " << x + 1 - pos.x << " tex: " << int(block->left)<< std::endl;
          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) {
          INFO << "zblock bottom: " << pos.z - z<< " tex: " << int(block->bottom)<< std::endl;
          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) {
          INFO << "zblock top: " << z + 1 - pos.z<< " tex: " << int(block->top) << std::endl;
          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::equip(uint8_t id) {
    if (id == 0) {
      activeWeapon = 0;
    }
    else {
      InventoryType::iterator i = inventory.find(id);
      if (i != inventory.end()) {
        activeWeapon = i->first;
      }
      else
        ERROR << "Ped does not have item type " << int(id) << std::endl;
    }
  }

  void Pedestrian::fireWeapon(Uint32 ticks) {
    if (activeWeapon == 0)
      return; // FIXME: punching!
    InventoryType::iterator i = inventory.find(activeWeapon);
    if (i->second == 0)
      return; // no ammo
    if (ticks < weaponReloadedAt)
      return;

    weaponReloadedAt = ticks + 2000;
    OpenGTA::SpriteManagerHolder::Instance().createProjectile(i->first, rot, pos, Vector3D(0.2f, 0, 0.2f), ticks);

  }

  void Pedestrian::update(Uint32 ticks) {
    // update the animation
    if (m_control) {
      switch(m_control->move) {
        case 1:
          if (!(animId == 2u + activeWeapon*3))
            switchToAnim(2 + activeWeapon*3);
          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);
    // update position/rotation
    Uint32 delta = ticks - lastUpdateAt;
    Vector3D moveDelta(0, 0, 0);
    if (m_control) {
      switch(m_control->turn) {
        case -1:
          rot -= 0.2f * delta;
          break;
        case 1:
          rot += 0.2f * delta;
          break;
        case 0:
          break;
      }
      if (rot >= 360.0f)
        rot -= 360.0f;
      if (rot < 0.0f)
        rot += 360.0f;
      switch(m_control->move) {
        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.1f;
      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;
    }
    lastUpdateAt = ticks;

  }

#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)

  Car::Car(const OpenGTA::Map::ObjectPosition & op) :
    SpriteObject(Vector3D(INT2FLOAT_WRLD(op.x), 6.05f-INT2FLOAT_WRLD(op.z), INT2FLOAT_WRLD(op.y))),
    OBox(RollMatrix3D(0), Vector3D()),
    c_info(*StyleHolder::Instance().get().findCarByModel(op.type)) {
    type = op.type;
    sprType = GraphicsBase::SpriteNumbers::CAR;
    sprNum = c_info.sprNum;
    m_Extent = Vector3D(INT2F_DIV128(c_info.width),
      INT2F_DIV128(c_info.depth),
      INT2F_DIV128(c_info.height));
    m_M.Translate(pos);
    rot = op.rotation * 360 / 1024;
  }

  Car::Car(const Car & other) : SpriteObject(other),
    OBox(other.m_M, other.m_Extent),
    c_info(*StyleHolder::Instance().get().findCarByModel(other.type)) {
    copyValues(other);
  }

  void Car::copyValues(const Car & other) {
    sprType = other.sprType;
    delta = other.delta;
    carId = other.carId;
    type = other.type;
  }

  GameObject::GameObject(const OpenGTA::Map::ObjectPosition & op) :
    SpriteObject(Vector3D(INT2FLOAT_WRLD(op.x), 6.05f-INT2FLOAT_WRLD(op.z), INT2FLOAT_WRLD(op.y))),
    OBox(RollMatrix3D(0), Vector3D()) {
    sprType = GraphicsBase::SpriteNumbers::OBJECT;
    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.Translate(pos);
    rot = op.rotation * 360 / 1024;

  }

  GameObject::GameObject(const GameObject & other) : SpriteObject(other),
    OBox(other.m_M, other.m_Extent) {
    copyValues(other);
  }

  void GameObject::copyValues(const GameObject & other) {
    sprType = other.sprType;
  }
}