laPivot.cpp

/*

Jump'n'Run Engine
http://www.atanaslaskov.com/jnr/

BSD LICENSE
Copyright (c) 2007-2013, Atanas Laskov
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL ATANAS LASKOV BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

//
// FILE: laPivot.cpp
// Material point simulation class
//
// Copyright (C) 2007-2013 Atanas Laskov, <latanas@gmail.com>
//
#include "stdafx.h"
#include "Core.h"

laCollider* laPivot::_pCollider = NULL;
laCollisionDomain *laPivot::_pFirstDomain = NULL;
unsigned long laPivot::_nDomains = 0;

laPivot::laPivot(void)
{
    angleX = angleY = angleZ = 0;

    bSimulateCollision =  bSimulateGravitation = M_TRUE;

    pTrap = NULL;
    bOnGround = M_FALSE;
    dShadowY = 0;

    velocity    = laPoint3();
    size        = laPoint3(M_UNIT/2.0, M_UNIT/2.0);
    mass        = 1;

    // Instantiate collider algorithm
    //
    if( ! laPivot::_pCollider ) {
        laPivot::_pCollider = new laCollider();
    }
}

// Simulate gravitation
// NOTE: This method updates the velocity.y() in accordance to gravitation,
// also taking in account collisions
//
void laPivot::_sim_gravitation(laTimer &t)
{
    PROFILE_COL(laPivot__sim_gravitation);
    laCollisionScenario csGravitation;

    csGravitation.pFirstDomain = _pFirstDomain;
    csGravitation.nDomains     = _nDomains;

    // Baseline used for checking if the player is on the ground
    //
    // NOTE: The +-M_NORMAL_RESPONSE is a fail-safe margin, and guarantees no false positives for (bOnGround);
    // In the same time it's important to have a *very small* margin ( like M_NORMAL_RESPONSE ),
    // otherwise there is a chance for false negatives when character lands on the very edge of the bounding box;
    //
    laLine2 lnBase( laPoint3(-size.x()*0.5 + M_NORMAL_RESPONSE, 0), laPoint3(+size.x()*0.5 - M_NORMAL_RESPONSE, 0) );

    // Initialize csGravitation to detect whether the object is flying or is on the ground
    //
    csGravitation.ptPosition    = (laPoint3)(*this);
    csGravitation.ptVector      = laPoint3(0, +M_GRAVITATIONAL_HOVER);

    _pCollider->collideLineWithDomain(lnBase, &csGravitation, 1, M_FALSE);
    bOnGround = csGravitation.bCollision;
    pTrap = NULL;

    if( csGravitation.bCollision )
    {
        // The object is on the ground, so nullify velocity along (y);
        // This prevents the object from gaining momentum while resting on a surface;
        //
        velocity[1] = M_MIN(0,  velocity.y());

        // Triggered a trap?
        if( csGravitation.bCollision && (csGravitation.pTrap!=NULL)  )
            pTrap = csGravitation.pTrap;
    }
    else
    {
        // Apply force of gravity
        velocity[1] += M_GRAVITATION_ACC*t.delta()*M_UNIT * mass;

        // Prevent from getting stuck at the ceiling when jumping
        //
        laLine2 lnTop( laPoint3(-size.x()*0.5 - M_NORMAL_RESPONSE, -size.y()), laPoint3(+size.x()*0.5 + M_NORMAL_RESPONSE, -size.y()) );
        csGravitation.ptVector.y( csGravitation.ptVector.y() * -1 );
        _pCollider->collideLineWithDomain(lnTop, &csGravitation, 1, M_FALSE);

        // If there was a collision with the ceiling, start dropping
        //
        if( csGravitation.bCollision ) velocity[1] = M_MAX(0,  velocity.y());
    }
}


// Simulate collisions
//
laPoint3 laPivot::_sim_collisions(laTimer &t)
{
    PROFILE_COL(laPivot__sim_collisions);
    laCollisionScenario cs;

    cs.pFirstDomain = _pFirstDomain;
    cs.nDomains     = _nDomains;

    // Sim collisions
    //
    cs.ptVector = _displacement_vector(t, velocity);
    cs.ptPosition = (laPoint3)(*this);

    // Object envelope
    //
    laLine2 ln[4];

    // NOTE: The upper line seems to resolve (partially) the 1-lonely-blcok penetration bug
    // Filtering it would require solving this bug
    //
    //if( cs.ptVector.y() >= 0)
        ln[0] = laLine2(laPoint2(-size.x()*0.5, 0), laPoint2(+size.x()*0.5,  0));
    //else
        ln[1] = laLine2(laPoint2(-size.x()*0.5, -size.y()), laPoint2(+size.x()*0.5, -size.y()));

    //if( cs.ptVector.x() >= 0)
        ln[2] = laLine2(laPoint2(+size.x()*0.5, 0), laPoint2(+size.x()*0.5, -size.y()));
    //else
        ln[3] = laLine2(laPoint2(-size.x()*0.5, 0), laPoint2(-size.x()*0.5, -size.y()));

    ::laSystemIntegrator::getRenderer()->styleSet( laColor(0,0,255) );
    ::laSystemIntegrator::getRenderer()->styleLine( 1 );
    for(unsigned i=0; i<4; i++) ln[i].draw(::laSystemIntegrator::getRenderer(), cs.ptPosition);
    ::laSystemIntegrator::getRenderer()->drawLine(cs.ptPosition, cs.ptPosition+cs.ptVector);

    _pCollider->collideLinesWithDomain(ln, 4, &cs, 3);
    return cs.ptModifiedVector;
}

// Project a false shadow
//
void laPivot::projectShadow()
{
    PROFILE_COL(laPivot_projectShadow);
    ASSERT(_pCollider, "Nil collider");
    ASSERT(_pFirstDomain, "Nil first collision domain");
    laCollisionScenario csShadow;

    csShadow.pFirstDomain   = _pFirstDomain;
    csShadow.nDomains       = _nDomains;
    csShadow.ptPosition     = (laPoint3)(*this);
    csShadow.ptVector       = laPoint2(0, M_UNIT*M_SEGH);

    _pCollider->collidePointWithDomain(&csShadow, 0, M_FALSE);
    dShadowY = y() + csShadow.ptModifiedVector.y() - M_NORMAL_RESPONSE*0.1;
}

// Query the collider with a vector
// NOTE: Can be used for implementing AI "tentacles" i.e. sensing the surroundsings of a monster
laPoint3 laPivot::projectVector( laPoint3 vector, M_BOOL *pTrapFlag, rpgTrap** ppTrap )
{
    PROFILE_COL(laPivot_projectVector);
    ASSERT(_pCollider, "Nil collider");
    ASSERT(_pFirstDomain, "Nil first collision domain domain");

    laCollisionScenario VectorCol;

    VectorCol.pFirstDomain  = _pFirstDomain;
    VectorCol.nDomains      = _nDomains;
    VectorCol.ptPosition    = (laPoint3)(*this);
    VectorCol.ptVector      = vector;

    _pCollider->collidePointWithDomain(&VectorCol, 1, M_FALSE);

    if(VectorCol.bCollision && pTrapFlag)
    {
        if(VectorCol.pTrap)
        {
            *pTrapFlag = M_TRUE;
            if(ppTrap) { *ppTrap = VectorCol.pTrap; }
        }
        else *pTrapFlag = M_FALSE;
    }

    return VectorCol.ptModifiedVector;
}


// Update velocity ( opt. without moving the object )
//
/*void laPivot::_sim_forces(laTimer &t, M_BOOL bAnimatePosition)
{
    laPoint3 acceleration;

    //Use all acting forces to calculate the acceleration
    for(unsigned i=0; i<lsForces.size(); i++)
    {
        lsForces[i]->_cbTrig.animate(t);

        acceleration[0] += lsForces[i]->compX()/mass;
        acceleration[1] += lsForces[i]->compY()/mass;

        if( lsForces[i]->_cbTrig.isEnabled() && (!lsForces[i]->_cbTrig.isElapsed()) )
            forceRemove(i);
    }

    //Apply the acceleration
    velocity += acceleration*t.delta();

    //Move the object according to the calculated speed (if requested)

    if(bAnimatePosition)
    {
        x += velocity.x()*t.delta()*M_UNIT;
        y += velocity.y()*t.delta()*M_UNIT;
    }
}*/

/*unsigned laPivot::forceAdd(laPhForce* f)
{
    lsForces.push_back(f);
    return lsForces.size()-1;
}

unsigned laPivot::forceAdd(laPhForce* f, double sec)
{
    unsigned i = forceAdd(f);
    lsForces[i]->_cbTrig.setHoldTime(sec);
    lsForces[i]->_cbTrig.enable();
    lsForces[i]->_cbTrig.reset();
    return i;
}

laPhForce* laPivot::forceRemove(unsigned id)
{
    ASSERT( id<lsForces.size(), "Attempt to remove unregistered force (%d)", id);

    lsForces.erase(lsForces.begin()+id);
    return NULL;
}

laPhForce* laPivot::forceGet(unsigned id)
{
    ASSERT( id<lsForces.size(), "Attempt to get unregistered force (%d)", id);
    return lsForces[id];
}*/