ScreenJunq.cpp

Go to the documentation of this file.

#include "global.h"
#include "ScreenJunq.h"
#include "MercuryScreenManager.h"
#include "MercuryInput.h"
#include "MercuryLog.h"
#include "MercuryTheme.h"
#include "MercuryCommands.h"
#include "MercuryDisplay.h"
#include "MercuryTheme.h"

extern MercuryTimer gameTimer;

KeyMappingWithCode( button_a, "0-97" );
KeyMappingWithCode( button_space, "0-32" );
KeyMappingWithCode( button_p, "0-121" );

#include "MercuryObjectFactory.h"
REGISTER_SCREEN_CLASS( ScreenJunq )

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

ScreenJunq::~ScreenJunq()
{
    DISPLAY->RemoveLight(&m_light);
    for(int i=0; i<64; i++)
    {
        SAFE_DELETE(m_Jsphere[i]);
    }
}

void ScreenJunq::Init()
{
    MercuryScreen::Init();

    for(int i=0; i<64; i++)
    {
        MercuryLoadableModel* m = new MercuryLoadableModel;
        m->SetName( ssprintf( "Ksphere%d", i ) );
        m->Init();
        m->Load(GET_MODEL_BY_NAME( "Jsphere" ));
        this->AddObject( m );
        m_Jsphere.push_back( m );
        m->MoveZ( -600);
        m->MoveX( (float)((i / 8) * 40 - 140) );
        m->MoveY( (float)((i % 8) * 40 - 140));
    }

    m_BPM = THEME.GetMetricI( m_name, "BPM" );
    m_In = ( ( 1.0f / ( (float)m_BPM / 60.0f ) ) * ( 1.0f/3.0f ) );
    m_Out = ( m_In * 2 );
    m_Beatctr = m_Peak = m_Measure =0;
    m_Type = THEME.GetMetricI( m_name, "BeatType" );
    m_Flow = THEME.GetMetricI( m_name, "BeatFlow" );

    if(m_Flow == 0)
    {
        Tweening.AddCommand( ssprintf( THEME.GetMetricS( m_name, "BeatTweenSm" ), (m_In), (m_Out) ), MercuryTweenState::GLOBAL, "BeatTween" );
    }else{
        Tweening.AddCommand( ssprintf( THEME.GetMetricS( m_name, "BeatTweenSm" ), (m_In * 3), (m_Out * 3) ), MercuryTweenState::GLOBAL, "BeatTween" );
            
    }

    m_iDirection = 0;
    m_Move=1;
    time = real = 0;

    //Setup a light
    m_light.Init();
    m_light.SetY(100);
    m_light.SetX(-100);
    m_light.SetZ(110);
    m_light.SetAttenuation(0.001f, Attenuation::LINEAR);
//  m_light.SetStatic(true);
    DISPLAY->AddLight(&m_light);

    this->RegisterMessage( MC_INPUTMAPPED, "mappedinput" );
}

void ScreenJunq::Message( int Message, PStack & data, const MString & name )
{
    switch ( Message ) 
    {
    case MC_INPUTMAPPED:
        {
            InputMessageStruct c(data);
            if ( (c.code == button_space ) && c.type == IET_RELEASE  )
            {
                m_Measure=16;
            }/*
            if ( c->code == button_p )
            {
                if ( c->type == IET_RELEASE )
                {
                    gameTimer.Pause();
                }
            }*/
            break;
        }
    };
}

void ScreenJunq::Update( const float dTime )
{
    time += dTime;
    if( time >= real )
    {
        m_Beatctr++; m_Measure++;
        PStack myStack;
        int i, j;
        switch (m_Type)
        {
        case 0:
            for(i=0; i<8; i++)
            {
                if(i<4)
                {
                    for(j=0; j<4; j++)
                    {
                        m_Jsphere[(i*8)+j+(m_Move*4)]->Tweening.StopTweening();
                        m_Jsphere[(i*8)+j+(m_Move*4)]->Tweening.ExecuteCommand( "BeatTween", myStack );
                    }
                }else{
                    for(j=0; j<4; j++)
                    {
                        m_Jsphere[(i*8)+j+((1-m_Move)*4)]->Tweening.StopTweening();
                        m_Jsphere[(i*8)+j+((1-m_Move)*4)]->Tweening.ExecuteCommand( "BeatTween", myStack );
                    }
                }
            }
            m_Move=1-m_Move;
            break;
        case 1:
            for(i=0; i<8; i++)
            {
                for(j=0; j<8; j++)
                {
                    if( (i==m_Move || j==m_Move) || (7-i==m_Move || 7-j==m_Move) )
                    {
                        m_Jsphere[(i*8)+j]->Tweening.StopTweening();
                        m_Jsphere[(i*8)+j]->Tweening.ExecuteCommand( "BeatTween", myStack );
                    }
                }
            }
            if(m_Move >= 3)
            {
                m_Move=0;
            }else{
                m_Move++;
            }
            break;
        case 2:
            for(i=0; i<8; i++)
            {
                for(j=0; j<7; j+=2)
                {
                    m_Jsphere[(i*8)+j+m_Move]->Tweening.StopTweening();
                    m_Jsphere[(i*8)+j+m_Move]->Tweening.ExecuteCommand( "BeatTween", myStack );

                }
                if(m_Move==0)
                    m_Move++;
                else
                    m_Move--;

            }
            if(m_Move==0)
                m_Move++;
            else
                m_Move--;
            break;
        case 3:
            for(i=0; i<8; i++)
            {
                for(j=0; j<8; j++)
                {
                    if( (i==3-m_Move || j==3-m_Move) || (7-i==3-m_Move || 7-j==3-m_Move) )
                    {
                        m_Jsphere[(i*8)+j]->Tweening.StopTweening();
                        m_Jsphere[(i*8)+j]->Tweening.ExecuteCommand( "BeatTween", myStack );
                    }
                }
            }
            if(m_Move >= 3)
            {
                m_Move=0;
            }else{
                m_Move++;
            }
            break;
        }
        if(m_Measure>=16)
        {
            if(m_Type>=3)
            {
                m_Type=0;
            }else{
                m_Type++;
            }
            m_Measure=0;
            m_Move=0;
        }

        /*
        
        m_Jsphere.Tweening.StopTweening();
        m_Jsphere.Tweening.AddCommand( ssprintf( THEME.GetMetricS( m_name, "BeatTween" ), m_In, m_Out ) );
        m_Jsphere.Tweening.ExecuteCommand( "BeatFlow3", PStack() );
        */
        real += (m_In * 3);
    }

    MercuryScreen::Update( dTime );
}



/*
 * (c) 2005 Benjamin Dailey
 * All rights reserved.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, and/or sell copies of the Software, and to permit persons to
 * whom the Software is furnished to do so, provided that the above
 * copyright notice(s) and this permission notice appear in all copies of
 * the Software and that both the above copyright notice(s) and this
 * permission notice appear in supporting documentation.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
 * THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS
 * INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT
 * OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

---

Hosted by