BetaBetaMari.cpp

Go to the documentation of this file.

#include "BetabetaMari.h"
#include "MercuryMath.h"
#include "MercuryTheme.h"

#define     MC_INPUTMAPPED      1       //convention: MESSAGE CODE
#define     MC_INPUTUNMAPPED    2
#define     MC_BETAJOIN         3

//Register the BetaBetaMari with MercuryODE
REGISTER_ODE_OBJECT_CLASS( BetaBetaMari );

BetaBetaMari::~BetaBetaMari()
{
}

void BetaBetaMari::Init()
{
    MercuryODEObjectLoadable::Init();

    //load wav file name from metric.ini
//  stick = SOUNDMAN->Load(THEME.GetMetricS(GetName(), "Stick"));
//  AddObject(stick);

    //Set up initial ball's size
    fOldMariSize = 7;
    fMariSize = 7;      

    //Generate the ball itself, and attach it to the local space
    m_pSph = dCreateSphere( m_oSpace, SQRT( fMariSize ) + 1 );
    dGeomSetBody( m_pSph, m_oBody );
    dGeomSetData( m_pSph, this );

    //Don't allow auto disbale on the control object or it will never move
    if (m_oBody)
        dBodySetAutoDisableFlag (m_oBody, false);

    this->RegisterMessage( MC_BETAJOIN, "betabetamarijoin" );
}

void BetaBetaMari::Update( const float dTime )
{
    //See if the mari grew
    if ( fOldMariSize != fMariSize )
    {
        dSpaceRemove( m_oSpace, m_pSph );   //Take out the old object
        fOldMariSize = fMariSize;

        //Generate the new ball collision object
        m_pSph = dCreateSphere( m_oSpace, SQRT( fMariSize )+1 );
        dGeomSetData( m_pSph, this );
        dGeomSetBody( m_pSph, m_oBody );
    }

    //Continue update cycle
    MercuryODEObjectLoadable::Update( dTime );
}

void BetaBetaMari::Message( int Message, PStack & data, const MString & name )
{
    if (Message == MC_BETAJOIN)
    {
        MercuryODEObjectLoadable* pHit2 = (MercuryODEObjectLoadable*)data.PeekItem(5).GetValueV();
        MercuryODEWorld* pWorld = (MercuryODEWorld*)data.PeekItem(4).GetValueV();
        fMariSize += data.PeekItem().GetValueF();       //Increase the size of our mari

        MercuryPoint DX(data.PeekItem(3).GetValueF(),
                        data.PeekItem(2).GetValueF(),
                        data.PeekItem(1).GetValueF());

        //Get the position of the contact
        DX = DX - GetPosition();    //And find the relative position

        //Verify that we didn't get a bogus hit.
        if( (SQRT( fMariSize )+1) * 1.1 < DX.Magnitude() )
            return;

//      stick->Play();

        //Begin dismantling the hit object
        dSpaceSetCleanup( pHit2->m_oSpace, 0 );

//      LOG.Info( ssprintf( "Marisize: %f\n", fMariSize ) );

        for ( unsigned int i = 0; i < pHit2->m_vAllTransforms.size(); i++ )
        {
            dGeomID Tran = dCreateGeomTransform( m_oSpace );    //Create a new transformation
            dGeomSetData( Tran, this );                         //And set the data for all geoms
            dGeomSetData( pHit2->m_vAllTransforms[i], this );
            dGeomSetData( pHit2->m_vAllGeoms[i], this );
            dGeomTransformSetCleanup( Tran, 1 );                //Configure the cleanup mode
            dGeomSetBody( pHit2->m_vAllTransforms[i], 0 );      //Attach all geoms to _this_ body
            dGeomSetBody( pHit2->m_vAllGeoms[i], 0 );
            dGeomSetBody( Tran, m_oBody );

            const dReal * MAT = dBodyGetRotation( m_oBody );    //Find the current rotation
            
            dGeomTransformSetGeom( Tran, pHit2->m_vAllTransforms[i] );
            if ( dGeomGetSpace( pHit2->m_vAllTransforms[i] ) == m_oSpace )
                dSpaceRemove( m_oSpace, pHit2->m_vAllTransforms[i] );

            //Multiply the matricies, to perform the rotation
            MercuryPoint DXO;
            DXO.x = DX.x * MAT[0] + DX.y * MAT[4] + DX.z * MAT[8];
            DXO.y = DX.x * MAT[1] + DX.y * MAT[5] + DX.z * MAT[9];
            DXO.z = DX.x * MAT[2] + DX.y * MAT[6] + DX.z * MAT[10];
            DX = DXO;

            //Set the position of the newly attached object
            dGeomSetPosition( pHit2->m_vAllTransforms[i], DX.x, DX.y,DX.z );
        }

        //Remove the newly attached object's old information
        pWorld->RemoveObject( pHit2, false );

        //Make it a child of _this_
        AddObject( pHit2, true );

        //Set its position, and other information
        pHit2->SetPosition(DX);
        pHit2->m_bBodied = false;

        //Destroy it's body information
        if (pHit2->m_oBody)
            dBodyDestroy( pHit2->m_oBody );

        //Clean out the old object
        pHit2->m_vAllGeoms.clear();
        pHit2->m_vAllTransforms.clear();
    }
}

bool BetaBetaMari::Collide( MercuryODEObject * pHit, dContact &pContact, MercuryODEWorld * pWorld )
{
    //Typecast pHit (Since we only have Loadables)
    MercuryODEObjectLoadable * pHit2 = (MercuryODEObjectLoadable*)pHit; 

    if ( !pHit2->m_bBodied )        //Make sure what we are colliding with has a body, otherwise act normally
        return true;
    if ( pHit == this )             //If we're colliding with part of ourself, ignore.
        return false;
    if ( pHit->m_oBody == m_oBody ) //If the representation of our body is identical to that of another, ignore.
        return false;

    //See if any of the contacts are with the sphere itself, if so, do a normal collision
    if ( pContact.geom.g1 != m_pSph && pContact.geom.g2 != m_pSph )
        return true;

    //Find the size of the object we're hitting
    float fSizeHit = pHit->GetParameter( "Size" ).GetValueF();

    //Make sure we're allowed to suck it up
    if (  fSizeHit == 0 || fSizeHit > SQRT( fMariSize ) / 1.7 )
        return true;

    PStack data;
    data.PushItem(PSElement((void*)pHit));
    data.PushItem(PSElement((void*)pWorld));
    data.PushItem(pContact.geom.pos[0]);
    data.PushItem(pContact.geom.pos[1]);
    data.PushItem(pContact.geom.pos[2]);
    data.PushItem(PSElement(fSizeHit));
    MESSAGEMAN->PostSystemMessage("betabetamarijoin", data, 0);

    return false;
}

/*
 * (PD) 2006 Charles Lohr
 * No rights reserved.
 * 
 * All code inside of this document is hereby released into the
 * public domain.  It may be used for any purpose without limitation.
 *
 */

---

Hosted by