ScreenFPS2.cpp

Go to the documentation of this file.

#include "ScreenFPS2.h"
#include "MercuryDisplay.h"
#include "MercuryTheme.h"
#include "MercuryInput.h"
#include "MercuryShapes.h"
#include "MercuryLog.h"
#include "MercuryTextureManager.h"

KeyMappingWithCode( button_a, "0-97" );
KeyMappingWithCode( button_b, "0-98" );
KeyMappingWithCode( button_s, "0-115" );
KeyMappingWithCode( button_d, "0-100" );
KeyMappingWithCode( button_w, "0-119" );
KeyMappingWithCode( button_mouse1, "0-1" );
KeyMappingWithCode( button_mouse2, "0-2" );
KeyMappingWithCode( button_u, "0-117" );
KeyMappingWithCode( button_t, "0-116" );
KeyMappingWithCode( button_space, "0-32" );

REGISTER_SCREEN_CLASS( ScreenFPS2 );

#define     MC_INPUTMAPPED      1       //convention: MESSAGE CODE
#define     MC_EXPLOSION        2       //convention: MESSAGE CODE

ScreenFPS2::~ScreenFPS2()
{
    m_pCamera = NULL;
}

void ScreenFPS2::Init()
{
    ScreenOutdoors::Init();

    pTweenCommands.resize(4);
    pTweenCommands[0].sAnimationName = "run_lower";
    pTweenCommands[0].fPercent = .5;
    pTweenCommands[1].sAnimationName = "run_upper";
    pTweenCommands[1].fPercent = .25;

    pTweenCommands[2].sAnimationName = "shootright_upper";
    pTweenCommands[2].bLoop = pTweenCommands[2].bRunning = false;
    pTweenCommands[3].sAnimationName = "shootleft_upper";
    pTweenCommands[3].fRate = 2;
    pTweenCommands[3].bLoop = pTweenCommands[3].bRunning = false;

    m_pPlayer.SetName( "jupiter" );
    m_pPlayer.Init();
    m_pPlayer.SetRotX( 90 );
    m_pPlayer.SetScale( MercuryPoint( 0.1f,0.1f,0.1f ) );
    m_pPlayer.Load( GET_MODEL_BY_NAME( "jupiter" ) );
    m_pPlayer.SetAnimationState( pTweenCommands );
    AddPerspObject( &m_pPlayer );

    pBullet.SetName( "BULLET" );
    pBullet.Init();
    pBullet.NotifyClass( this, "rayhit" );
    pBullet.SetDrawOrder( 10000 );
    AddPerspObject( &pBullet, false );

    m_Aimer.SetName( "BULLET Aimer" );
    m_Aimer.Init();
    m_Aimer.NotifyClass( this, "aimhit" );
    m_oldInter = m_interactable = false;
    fClosestAimerObject = 100000;

    pPhysics.SetName( "PHYSGUN" );
    pPhysics.Init();
    pPhysics.NotifyClass( this, "physhit" );
    pPhysics.SetDrawOrder( 10000 );
    AddPerspObject( &pPhysics, false );
    iPhysicsObject = 0;
    fClosestPhysicsObject = 100000;

    m_pINI.Open( GET_FILE_BY_NAME( "IniFile" ) );

    m_pWorld.Init();
    m_pWorld.LoadFromINI( m_pINI, THEME.GetMetricS( m_name, "WorldName" ) );
    AddPerspObject( &m_pWorld );

    m_fCamera.SetName( "Camera" );
    m_fCamera.Init();
    m_fCamera.SetUp(MercuryPoint(0,0,1));
    m_pCamera = &m_fCamera;
    m_fCamera.Tweening.AddCommand( THEME.GetMetricS( m_name, "CamTween" ), MercuryTweenState::LOCAL, "CamTween" );

    m_fTimeSinceLastShot = 0;
    m_fForwardMovement = 0;

    m_bFPS = true;
    m_sprCrosshairs.SetName( "Crosshairs" );
    m_sprCrosshairs.Init();
    m_sprCrosshairs.LoadImage( "GRAPHIC:targetret2.png" );
    m_sprCrosshairs.SetPosition( MercuryPoint( 320,240, 0 ) );
    m_sprCrosshairs.SetDrawOrder( 10001 );
    m_sprCrosshairs.Tweening.AddCommand( THEME.GetMetricS( m_name, "CrosshairsOnTarget" ), MercuryTweenState::LOCAL, "OnTarget" );
    m_sprCrosshairs.Tweening.AddCommand( THEME.GetMetricS( m_name, "CrosshairsOffTarget" ), MercuryTweenState::LOCAL, "OffTarget" );
    m_sprCrosshairs.Tweening.ExecuteCommand("OffTarget", PStack());
    AddOrthoObject( &m_sprCrosshairs );

    m_sprCrosshairsCenter.SetName( "CrosshairsCenter" );
    m_sprCrosshairsCenter.Init();
    m_sprCrosshairsCenter.LoadImage( "GRAPHIC:targetret.png" );
    m_sprCrosshairsCenter.SetPosition( MercuryPoint( 320,240, 0 ) );
    m_sprCrosshairsCenter.SetDrawOrder( 10000 );
    AddOrthoObject( &m_sprCrosshairsCenter );


    m_DynTex.AttachTexture( "DYNCUBE:hello,256,256,0" );

    m_DynTex.Init();
//  m_DynTex.AddObject( &m_pWorld, false );
    MercuryShape * k = new MercuryShape;
    k->SetName( "testshape" );
    k->Init();
    k->LoadImage( "GRAPHIC:test3.ini" );
    k->SetScale( MercuryPoint( 4,4,4 ) );
    k->MakeBox();
    k->SetPosition( MercuryPoint( 0,0,5));
    k->Tweening.AddCommand( "linear,1000;rotationx,108000" );
    m_DynTex.AddObject( k, true );
//  m_DynTex.AddObject( &m_pPlayer );
    m_DynTex.SetDrawOrder( -100 );
    AddPerspObject( &m_DynTex, false );


    RegisterMessage( MC_INPUTMAPPED, "mappedinput" );
    RegisterMessage( MC_EXPLOSION, "DoExplosion" );
    m_slowDown = false;
    m_fistExplosion = m_donefirst = false;
}

void ScreenFPS2::CalculateMovement(MercuryODEObject* control)
{
    int dx=0;
    int dy=0;
    if ( INPUTMAN->IsButtonDown( button_d ) )
        dy -= 5;
    if ( INPUTMAN->IsButtonDown( button_a ) )
        dy += 5;
    if ( INPUTMAN->IsButtonDown( button_w ) )
        dx += 5;
    if ( INPUTMAN->IsButtonDown( button_s ) )
        dx -= 5;

    float Amplitude = SQRT(float((dx*dx)+(dy*dy)));
    float AngleToGo=ATAN2(float(dx),float(-dy));

    MercuryPoint Target = m_pWorld.GetODEObjectByName( "Control" )->GetPosition();
    MercuryPoint From = Target - pTarget;

    float AngleDiff=ATAN2((From-Target).x,(From-Target).y);
    float RealAngle = AngleToGo - AngleDiff - 1.57f;

    dBodyEnable( control->m_oBody );
    dBodySetAngularVel( control->m_oBody, COS(RealAngle)*Amplitude,SIN(RealAngle)*Amplitude,0); 
    
    //Handle Jumping
    if( INPUTMAN->IsButtonDown( button_space ) )
    {
        dBodyAddForce( control->m_oBody, SIN(RealAngle)*Amplitude*800,-COS(RealAngle)*Amplitude*800,3900 );
    }

    //Now, Update the robot's animations
    PlayRobotAnimations(dx);
}

void ScreenFPS2::PlayRobotAnimations(int dx)
{
    if (m_fForwardMovement > 0 )
        m_fForwardMovement = (m_fForwardMovement + float(dx)/50) - 0.025f;
    else
        m_fForwardMovement = (m_fForwardMovement + float(dx)/50) + 0.025f;

    m_fForwardMovement = Clamp( m_fForwardMovement, -1.0f, 1.0f );

    if( m_fForwardMovement < 0.05 && m_fForwardMovement > -0.05f )
        m_fForwardMovement = 0;

    m_pPlayer.GetAllAnimationStates( pTweenCommands );
    pTweenCommands[0].fPercent = m_fForwardMovement;
    pTweenCommands[0].fRate = ABS(m_fForwardMovement)*1.5f;
    pTweenCommands[1].fPercent = m_fForwardMovement/2;
    pTweenCommands[1].fRate = ABS(m_fForwardMovement)*1.5f;

    if( m_fTimeSinceLastShot == 0 )
        pTweenCommands[3].Trigger();

    m_pPlayer.SetAnimationState( pTweenCommands );
}

void ScreenFPS2::Update( const float dTime )
{
    if (dTime == 0)
        return;

    if ( m_bFirstUpdate )
    {
        m_bFirstUpdate = false;
        return;
    }

    float adjTime = dTime;
    if (m_slowDown > 0)
    {
        m_slowDown -= dTime;
        adjTime /= 5;
    }

    if ((m_slowDown <= 0) && m_fistExplosion)
    {
        m_donefirst = true;
        m_slowDown = 0;
    }

    //hack to move water
    MercuryODEObjectLoadable* water = (MercuryODEObjectLoadable*)m_pWorld.GetODEObjectByName("Water");
    if (water)
    {
        water->GetGLState().Disable(MGLS_OPAQUE);
        MercuryShape* s = (MercuryShape*)water->m_vMercuryShapes[0];
        if (s)
        {
            MercuryMaterial* mw = s->GetMaterial(0);
            if (mw)
            {
                mw->EditTexture(0)->MoveY( dTime/THEME.GetMetricF( m_name, "WaterPeriodSecY" ));
                mw->EditTexture(0)->MoveX( dTime/THEME.GetMetricF( m_name, "WaterPeriodSecX" ));
            }
        }
    }

    int x, y;
    INPUTMAN->GetCursorPosition(x, y);
    MercuryODEObject* control = m_pWorld.GetODEObjectByName( "Control" );

    CalculateMovement(control);

    //Must happen before aim shot to keep targeting smooth
    CalculateLook(x, y, control);

    //Do before Physics Update to stay smooth
    m_Aimer.Disable();
    m_Aimer.EnableForShot( m_pWorld.GetWorldSpaceID(), 50000, m_pGun, pLookAt );

    ScreenOutdoors::Update( adjTime );

    //Must happen after physics update to stay smooth
    TweenCamera(x, y, control);

    m_pPlayer.SetPosition( control->GetPosition( ) );

    pPhysics.Disable();
    //do physics if necessiary
    if ( iPhysicsObject != 0 )
    {
        //Physics!
        MercuryPoint pNewPos = m_pGun + pLookAt.Normalize() * fClosestPhysicsObject;
        fClosestPhysicsObject = fClosestPhysicsObject * 0.95f + 2;
        MercuryPoint pCurrentPos( dBodyGetPosition( (dBodyID)iPhysicsObject ) );
        //dBodySetPosition( (dBodyID)iPhysicsObject, pPos.x, pPos.y, pPos.z );

        MercuryPoint pDir = pNewPos-pCurrentPos;
        pDir *= (0.4f/dTime);
        dBodySetLinearVel( (dBodyID)iPhysicsObject, pDir.x, pDir.y, pDir.z );
        dBodyEnable( (dBodyID)iPhysicsObject );
    }

//      m_sprCrosshairs.SetHide( (m_slowDown > 0 && !m_donefirst) );

    m_fTimeSinceLastShot += dTime;
    pBullet.Disable();
    if( m_fTimeSinceLastShot > .25 && INPUTMAN->IsButtonDown( button_mouse1 ) )
    {
        m_fTimeSinceLastShot = 0;
        pBullet.EnableForShot( m_pWorld.GetWorldSpaceID(), 50000, 
            m_pGun, pLookAt );
    }

    //aimer result
    {
        if ( m_interactable )
        {
            if( m_interactable != m_oldInter )
            {
                m_sprCrosshairs.Tweening.StopTweening();
                m_sprCrosshairs.Tweening.ExecuteCommand("OnTarget", PStack());
            }
        }
        else
        {
            if( m_interactable != m_oldInter )
            {
                m_sprCrosshairs.Tweening.StopTweening();
                m_sprCrosshairs.Tweening.ExecuteCommand("OffTarget", PStack());
            }
        }
        m_oldInter = m_interactable;
        MercuryPoint xy = PointToScreenCoord(m_perspProjection.m_matrix, m_pCamera->GetFinalMatrix(), m_aimPos, DISPLAY->GetDimensions());
        xy.z = 0;
        m_sprCrosshairs.SetPosition(xy);
        fClosestAimerObject = 10000;
    }

    m_pPlayer.SetRotY( -float(x)/300*RADDEG );

    //Tricky: find where the gun is shooting from, for this we can use some basic trigonometry.
    m_pGun = control->GetPosition();
    m_pGun.x += cos( -float(x)/300 + Q_PI/4)*7;
    m_pGun.y += sin( -float(x)/300 + Q_PI/4)*7;
}

void ScreenFPS2::CalculateLook(int x, int y, MercuryODEObject* control)
{

    if( ( y - m_iSlidingF ) > 470 )
        m_iSlidingF = y - 470;
    if( ( y - m_iSlidingF ) < -470 )
        m_iSlidingF = y + 470;

    pTarget.x = cos( -float(x)/300 );
    pTarget.y = sin( -float(x)/300 );
    pTarget.z = 0;

    pLookAt = pTarget;

    pLookAt.x *= cos( -float(y-m_iSlidingF)/300 );
    pLookAt.y *= cos( -float(y-m_iSlidingF)/300 );
    pLookAt.z = sin( -float(y-m_iSlidingF)/300 );
}

void ScreenFPS2::TweenCamera(int x, int y, MercuryODEObject* control)
{
    if ( !((m_slowDown > 0) && !m_donefirst))
        if( !m_bFPS )
        {
            m_fCamera.Tweening.StopTweening();

            m_fCamera.Tweening.ExecuteCommand( "CamTween", PStack( 
                    PSElement( control->GetX()-COS(-float(x)/300)*30 ),
                    PSElement( control->GetY()-SIN(-float(x)/300)*30 ),
                    PSElement( (control->GetZ())+25)));

            MercuryPoint pos = m_fCamera.GetPosition();

            m_pPlayer.SetHide( false );
            m_fCamera.SetTarget( pLookAt + pos );

            MercuryPoint pNewUp = pLookAt.CrossProduct( MercuryPoint( 0,0,1 ) );
            pNewUp = pNewUp.CrossProduct( pLookAt );
            m_fCamera.SetUp( pNewUp );

        } else {
            m_fCamera.SetPosition( control->GetPosition() );
            m_pPlayer.SetHide( true );
            m_fCamera.SetTarget( pLookAt + control->GetPosition() );

            MercuryPoint pNewUp = pLookAt.CrossProduct( MercuryPoint( 0,0,1 ) );
            pNewUp = pNewUp.CrossProduct( pLookAt );
            m_fCamera.SetUp( pNewUp );
        }
}

void ScreenFPS2::Message( int Message, PStack & data, const MString &name )
{
    switch ( Message ) 
    {
    case MC_INPUTMAPPED:
        {
            InputMessageStruct c(data);
            if ( c.code == button_u )
            {
                if ( c.type == IET_DOWN )
                {
                    m_bFPS = !m_bFPS;
                }
            } else if ( c.code == button_b && c.type != IET_RELEASE ) {
                m_pWorld.GenAndAddToWorld( m_pINI, "MyBall", "Ball", "MercuryODEObjectLoadable", 1, MercuryPoint(0,0,100));
            } else if ( c.code == button_t && c.type == IET_DOWN ) {
                m_pWorld.GenAndAddToWorld( m_pINI, "MyBall", "coke", "ExplodingCokeCan", 1, MercuryPoint(0,0,100));
            } else if ( c.code == button_mouse2 )
            {
                if ( c.type == IET_DOWN )
                {
                    pPhysics.EnableForShot( m_pWorld.GetWorldSpaceID(), 50000, 
                        m_pGun, pLookAt );
                }
                else if( c.type == IET_RELEASE )
                {
                    iPhysicsObject = 0;
                    fClosestPhysicsObject = 100000;
                }
            }
        }
        break;
    case MC_EXPLOSION:
        {
            if (!m_fistExplosion)
            {
                m_slowDown += 2;
//              MercuryODEObject * c = m_pWorld.GetODEObjectByName( "Control" );

                MercuryPoint coke;
                coke.SetX(data.PeekItem(0).GetValueF());
                coke.SetY(data.PeekItem(1).GetValueF());
                coke.SetZ(data.PeekItem(2).GetValueF());
                MercuryPoint a = (coke - m_fCamera.GetPosition()).CrossProduct( MercuryPoint(0,0,1));
                a.NormalizeSelf();
                m_fCamera.Tweening.StopTweening();
                m_fCamera.Tweening.AddCommand( ssprintf( "linear,%f;x,%f;y,%f;z,%f", m_slowDown/5, coke.x-50, coke.y-50, coke.z+50));

    //          m_fCamera.Tweening.AddCommand( ssprintf( "linear,0.4;addx,%f;addy,%f;addz,%f", a.x*300, a.y*300, a.z*-600));
    //          m_fCamera.Tweening.AddCommand( ssprintf( "linear,0.2;movex,%f;y,%f;z,%f;",  
                m_fCamera.SetTarget(coke);
    //          m_fCamera.SetTarget(c->GetPosition() + MercuryPoint( 0,0,15));

                MercuryPoint pNewUp = pLookAt.CrossProduct( MercuryPoint( 0,0,1 ) );
                pNewUp = pNewUp.CrossProduct( pLookAt );
                m_fCamera.SetUp( pNewUp );
                m_pPlayer.SetHide( false );
                m_fistExplosion = true;
            }
        }
        break;
    };

    ScreenOutdoors::Message( Message, data, name );
}

bool ScreenFPS2::Command( PStack & ret, const char * command, PStack & args )
{
    if ( strcmp( command, "physhit" ) == 0 )
    {
        if( args.PeekItem( 0 ).GetValueS().compare( "EarthControl" ) == 0 )
            return true;
        MercuryODEObjectLoadable * L = (MercuryODEObjectLoadable*)args.PeekItem( 1 ).GetValueV();
        if( L->m_oBody )
        {
            MercuryPoint pPos = MercuryPoint(  args.PeekItem( 2 ).GetValueF(), 
                args.PeekItem( 3 ).GetValueF(), 
                args.PeekItem( 4 ).GetValueF() ) - m_pGun;
            
            float fDistance = pPos.Magnitude();

            if( fDistance < fClosestPhysicsObject )
            {
                iPhysicsObject = (MVPtr)L->m_oBody;
                fClosestPhysicsObject = fDistance;
            }
        }
        return true;
    }
    else if ( strcmp( command, "rayhit" ) == 0 )
    {
        if( args.PeekItem( 0 ).GetValueS().compare( "EarthControl" ) == 0 )
            return true;
        //Order of args: NameOfObject, (void*)ObjectHandle, fX, fY, fZ, fNX, fNY, fNZ
        MercuryODEObjectLoadable * L = (MercuryODEObjectLoadable*)args.PeekItem( 1 ).GetValueV();
        if( L->m_oBody )
        {
            dBodyEnable( L->m_oBody );

            dBodyAddForce( L->m_oBody, 70000*args.PeekItem( 5 ).GetValueF(),
                70000*args.PeekItem( 6 ).GetValueF(),
                70000*args.PeekItem( 7 ).GetValueF() );
        }

        MercuryShape * k = (MercuryShape*)Spawn( "MercuryShape", "bob" );
        k->MakeSphere();
        k->LoadImage( "GRAPHIC:Explosion.ini" );
        k->SetDiffuse( MercuryColor( 1,1,1,1 ) );
        k->SetScale( gpOne );
        MercuryPoint p(MercuryPoint( args.PeekItem( 2 ).GetValueF(), args.PeekItem( 3 ).GetValueF(), args.PeekItem( 4 ).GetValueF() ));
        k->SetPosition( p );
        k->Tweening.AddCommand( THEME.GetMetricS( GetName(), "BulletExplosion", "" ) );
        k->GetGLState().Disable(MGLS_OPAQUE);

        MercuryMaterial m;
        MercuryLight* l = (MercuryLight*)Spawn("MercuryLight", "Explosion light");
        l->SetColors(m);
        l->SetPosition(p);
        l->SetStatic(true);
        l->SetLightType(LT_POINT);
        l->SetAttenuation(.001f,Attenuation::QUADRATIC);
        l->Tweening.AddCommand(THEME.GetMetricS( GetName(), "LightExplosion", "" ));
        DISPLAY->AddLight(l);

        return true;
    }
    else if ( strcmp( command, "aimhit" ) == 0 )
    {
        if( args.PeekItem( 0 ).GetValueS().compare( "EarthControl" ) == 0 )
            return true;
        MercuryODEObjectLoadable * L = (MercuryODEObjectLoadable*)args.PeekItem( 1 ).GetValueV();

        MercuryPoint pPos = MercuryPoint(  args.PeekItem( 2 ).GetValueF(), 
            args.PeekItem( 3 ).GetValueF(), 
            args.PeekItem( 4 ).GetValueF() );
            
        float fDistance = (m_pPlayer.GetPosition()-pPos).Magnitude();

        if( fDistance < fClosestAimerObject )
        {
            if (L->m_oBody)
                m_interactable = true;
            else
                m_interactable = false;

            fClosestAimerObject = fDistance;
            m_aimPos = pPos;
        }

        return true;
    }

    return ScreenOutdoors::Command( ret, command, args );
}

/* 
 * Copyright (c) 2006, Charles Lohr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   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.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * 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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
 */

---

Hosted by