random_racer/src/LoaderGlue.cpp

Go to the documentation of this file.

#include <math.h>
#include <stdarg.h>
#include <stdio.h>

#include <sstream>

#include <vrsode/CollisionBody.h>
#include <vrsode/PlaneShape.h>
#include <vrsode/PhysicsManager.h>

#include "Console.h"
#include "ItemDistributor.h"
#include "ReloadPlane.h"
#include "TerrainLoader.h"

#include "LoaderGlue.h"

using namespace VRS;
using namespace vrsode;


namespace random_racer
{

LoaderGlue::LoaderGlue(
    SO<CollisionBody> p_collisionBody,
    SO<TerrainLoader> p_loader,
    float p_boxSize,
    float p_centerDiff,
    Vector p_position,
    SO<ItemDistributor> p_itemDistributor)
{
    m_carBody       = p_collisionBody;
    m_loader        = p_loader;
    m_halfBoxSize   = p_boxSize/2.0;
    m_centerDiff    = p_centerDiff;
    m_position      = p_position;
    m_callback      = new MethodCallback1<LoaderGlue, unsigned int>(
                          this, &LoaderGlue::collisionCallback);
    m_itemDistributor = p_itemDistributor;
}

LoaderGlue::~LoaderGlue()
{
}

void
LoaderGlue::collisionCallback(unsigned int p_id)
{
    // std::cout << "ZACK " << p_id
    //           << (p_id > 3 ? "  ODE " : " (VRS)") << std::endl;

    // ok, we have 8 possible new center points for our
    // new planes, this is how they are located, the dot
    // is our previous position.
    //
    //   7    0    1
    //
    //   6    .    2
    //
    //   5    4    3
    //
    // the difference between 0 and . is m_centerDiff
    Point candidates[8];

    // FIXME: maybe optimize this if there is time

    // fill all possible next points with defaults
    for(unsigned int i = 0; i < 8; i++)
    {
        // 0, 1, 7
        if(i == 7 || i <= 1)
            candidates[i].y = m_position[2] + m_centerDiff;

        else if(i == 6 || i == 2)
            candidates[i].y = m_position[2];

        else
            candidates[i].y = m_position[2] - m_centerDiff;

        // 1, 2, 3
        if(i != 0 && i <= 3)
            candidates[i].x = m_position[0] + m_centerDiff;

        else if(i == 0 || i == 4)
            candidates[i].x = m_position[0];

        else
            candidates[i].x = m_position[0] - m_centerDiff;
    }

    // find the nearest possible next plane center for the cars
    // current position.
    Vector pos = m_carBody->position();
    unsigned int nearest = TerrainLoader::nearestIndex(
                                                 pos[0], pos[2], candidates, 8);

    // remember this position for the next time
    m_position[0] = candidates[nearest].x;
    m_position[2] = candidates[nearest].y;


    // lock only if we are in vrs thread and the reloacte the planes
    if(p_id < 4)
    {    
        PhysicsManager::get()->lock();
        relocatePlanesAround(candidates[nearest].x, candidates[nearest].y);
        PhysicsManager::get()->unlock();
    }
    else
        relocatePlanesAround(candidates[nearest].x, candidates[nearest].y);


    // tell the loader to replace our terrain
    m_loader->replaceTerrain(
            m_carBody->position(),
            Vector(candidates[nearest].x, 0.0, candidates[nearest].y));


    // tell the itemditributor to distribute new coins
    if(m_itemDistributor != NULL)
        m_itemDistributor->distributeItems(3, m_carBody->position(), 
                m_loader->viewSize() / 3.0);
}

void
LoaderGlue::registerPlanes(SO<ReloadPlane>* p_planeArray)
{
    for(unsigned int i = 0; i < 4; i++)
        m_planes[i] = p_planeArray[i];

    m_planes[0]->relocate(Vector(-1,0,0), 0.0);
    m_planes[1]->relocate(Vector(1,0,0),  0.0);
    m_planes[2]->relocate(Vector(0,0,-1), 0.0);
    m_planes[3]->relocate(Vector(0,0,1),  0.0);

    Vector pos = m_carBody->position();
    relocatePlanesAround(pos[0], pos[2]);
}

void
LoaderGlue::relocatePlanesAround(double p_x, double p_y)
{
    // std::cout << "locating around " << p_x << ", "<< p_y << std::endl;

    m_planes[0]->relocate( -(m_halfBoxSize) - p_x );
    m_planes[1]->relocate( p_x - (m_halfBoxSize)  );
    m_planes[2]->relocate( -(m_halfBoxSize) - p_y );
    m_planes[3]->relocate( p_y - (m_halfBoxSize)  );
}

void
LoaderGlue::checkForCollisions()
{
    for(unsigned int i = 0; i < 4; i++)
        m_planes[i]->checkForCollision();
}

} // namespace random_racer

---