Controllers.cpp

Go to the documentation of this file.

#include <cmath>
#include <stdlib.h>
#include <stdio.h>
#include "Internal.h"
#include "QVector.h"
#include "Controllers.h"
#include "MenuDisplay.h"
#include "XRes.h"
#include "Bongo.h"
#include "Arrow.h"

using namespace std;

MenuController::MenuController(MenuDisplay* menu)
    : mpMenu(menu) 
{
}  

bool MenuController::ProcessKey(int key, Engine::KeyEvent type, int x, int y)
{
    if (type == Engine::KEY_UP_EX)
        return false;

    switch (key)
    {
    case GLUT_SPEC_KEY_UP:
        mpMenu->FocusPrev();
        return true;
    case GLUT_SPEC_KEY_DOWN:
        mpMenu->FocusNext();
        return true;
    case ' ':
    case 13:
        mpMenu->Select();
    return true;
    }

    return false;
}

bool ShortcutController::ProcessKey(int key, Engine::KeyEvent type, int x, int y)
{
    if (type == Engine::KEY_UP_EX)
    {
        return false;
    }
    switch (key)
    {
    case 'p':
    case 'P':
        if (mbPaused)
            mpParent->Resume(true);
        else
            mpParent->Pause();

        mbPaused = !mbPaused;
        return true;
    case 27: //< Escape
        // send cancelation event ot whoever cares
        mpParent->SendEvent(EventListener::EV_CANCEL);

        // If Active Menu is Display Menu get back to game.
        if (mpParent->ActiveDisplay() == mpParent->GetMenuDisplay() )
        {
            mpParent->SetActiveDisplay(mpParent->StatusDisplay() );
            mpParent->SetActiveController(mpParent->BongoMover() );
            mpParent->Resume(true);              
        }
        else
        {
            // Pause game and go to display menu.
            mpParent->Pause();
            mpParent->SetActiveController(mpParent->GetMenuController() );
            mpParent->SetActiveDisplay(mpParent->GetMenuDisplay() );
            glutPostRedisplay();
        }

        return true;   
        // Cheat key. Next Level.
    case 'n':
    case 'N':
        mpParent->NextLevel();
        return true; 
        // Cheat key. Previous Level.
    case 'b':  
    case 'B':
        {
            if (mpParent->CurrentLevel() == 1)
            {
                break;
            }
            if (!mpParent->LoadLevel(mpParent->CurrentLevel() - 1) )
            {
                printf("error: failed to load level: %d\n", mpParent->CurrentLevel() - 1);
            }
            return true;   
        }

    }
    return false;
}  

bool BongoOrthoMover::Init(XRes* resource, XCongo *xcongo)
{
    if (!resource->DoubleValue("mPower", &mPower) )
    {
        fprintf(stderr, "error: BongoOrthoMover power\n");
        return false;
    }
  
    return true;
}

BongoOrthoMover::BongoOrthoMover(Engine* parent, Bongo* pquad)
: mpParent(parent), mpBongo(pquad), mPower(2.0)
{
    m_k = mpParent->mBoxDim[2] / mpParent->mBoxDim[0];
    m_lz = mpParent->mBoxDim[2];
    mnMoving = 0;
    memset(mDirectionLU, 0, sizeof(mDirectionLU) );
    memset(mDirectionRD, 0, sizeof(mDirectionRD) );
}

bool BongoOrthoMover::ProcessKey(int key, Engine::KeyEvent type, int px, int py)
{
    double nula[] = { 0.0, 0.0, 0.0 };
    
    if (!mpParent->mbAnimeEnabled)
        return true;

    if (!mpBongo->IsActive() )
        return true;

  /*  if (mnMoving > 1)
    {
        memset(mDirectionRD, 0, sizeof(mDirectionRD) );
        memset(mDirectionLU, 0, sizeof(mDirectionLU) );
        mnMoving = 0;
    }
    */ 
    bool moved = false;

    double  x, y, z;
    mpParent->GetViewer(&x, &y, &z);
    
    double 
        t1 = m_k * x + z - m_lz,
        t2 = -m_k * x + z;
 
    double pow = 0.0;
    int    movd = -1;

    if (type == Engine::KEY_DOWN_EX)
    {
        movd = +1;
        pow = mPower;
    }

    switch (key)
    {
    case GLUT_SPEC_KEY_LEFT:       
        if (t1 >=0 && t2 >= 0)
            mDirectionLU[0] = -pow;
        else if (t1 >=0)
            mDirectionLU[2] = pow;
        else if (t2 >=0)
            mDirectionLU[2] = -pow;
        else
            mDirectionLU[0] = pow;
              
        mnMoving += movd;
        moved = true;       
        break;  
     case GLUT_SPEC_KEY_RIGHT:
        if (t1 >=0 && t2 >= 0)
            mDirectionRD[0] = pow;
        else if (t1 >=0)
            mDirectionRD[2] = -pow;
        else if (t2 >=0)
            mDirectionRD[2] = pow;
        else
            mDirectionRD[0] = -pow;
        mnMoving += movd;
        moved = true;       
        break; 
     
     case GLUT_SPEC_KEY_UP:
        if (t1 >=0 && t2 >= 0)
            mDirectionLU[2] = -pow;
        else if (t1 >=0)
            mDirectionLU[0] = -pow;
        else if (t2 >=0)
            mDirectionLU[0] = pow;
        else
            mDirectionLU[2] = pow;

        mnMoving += movd;
        moved = true;
        break; 
     case GLUT_SPEC_KEY_DOWN:
        if (t1 >=0 && t2 >= 0)
            mDirectionRD[2] = pow;
        else if (t1 >=0)
            mDirectionRD[0] = pow;
        else if (t2 >=0)
            mDirectionRD[0] = -pow;
        else
            mDirectionRD[2] = -pow;
        moved = true;
        
        mnMoving += movd;
        break; 
    
     case ' ': 
        {
            if (Engine::KEY_UP_EX == type)
                break;
            Quad *q = mpBongo->Fire();
            if (q)
            {
                mpParent->mQuads.push_front(q);
            }
        }
        break;
    }

    if (moved)
    {
        double dir[3];
        memset(dir, 0, sizeof(dir) );
        vec_add(dir, mDirectionLU);
        vec_add(dir, mDirectionRD);
        mpBongo->SetDirection(dir);
    }

    return true;
}

BongoRealMover::BongoRealMover(Engine* parent, Bongo* pquad)
: mpParent(parent), mpBongo(pquad), mbMoving(false)
{
    mpParent->GetViewer(mDirection, mDirection + 1, mDirection + 2);

    vec_ofpow(mDirection, -mPower);
    mDirection[1] = 0.0;
}


bool BongoRealMover::Init(XRes* resource, XCongo *xcongo)
{
    if (!resource->DoubleValue("mPower", &mPower) )
    {
        fprintf(stderr, "error: BongoRealMover power\n");
        return false;
    }
  
    return true;
}


bool BongoRealMover::ProcessKey(int key, Engine::KeyEvent type, int x, int y)
{
    double dir[3] = { 0.0, 0.0, 0.0 };
    if (Engine::KEY_UP_EX == type)
    {
        if (GLUT_SPEC_KEY_UP == key || GLUT_SPEC_KEY_DOWN == key)
        {
            mbMoving  = false;
            mpBongo->SetDirection(dir);
        }
        return true;
    }

    switch (key)
    {
    case GLUT_SPEC_KEY_UP:
        mpBongo->SetDirection(mDirection);
        mbMoving = true;
          
        break;
    case GLUT_SPEC_KEY_DOWN:
        {
            memcpy(dir, mDirection, sizeof(dir) );
            vec_mul(dir, -1.0);
            mpBongo->SetDirection(dir);
            mbMoving = true;
          
            break;
        }
    case GLUT_SPEC_KEY_LEFT:
        {
            
            vec_rotateY(mDirection, M_PI * 5 *mPower /2);
            if (mbMoving)
                mpBongo->SetDirection(mDirection);
            break;
        }
    case GLUT_SPEC_KEY_RIGHT:
        {
            vec_rotateY(mDirection, -M_PI * 5 *mPower /2);
            if (mbMoving)
                mpBongo->SetDirection(mDirection);
            break;
        }
    case ' ': 
        {
            Quad *q = mpBongo->Fire();
            if (q)
                mpParent->mQuads.push_back(q);
        }
        break;
    }

    return true;
}

ViewController::ViewController(Engine* parent) 
    : mpParent(parent), mbKeyInProcessing(false)
{
}

bool ViewController::Init(XRes* resource, XCongo *xcongo)
{
    if (!resource->DoubleValue("mDeltaAngle", &mDeltaAngle) ||
        !resource->DoubleValue("mDeltaDis", &mDeltaDis) )
    {
        fprintf(stderr, "error: reading ViewControler parameters\n");
        return false;   
    }
    
    return true;
}

static void count_depolar(double teta, double gama, double rad, 
                          double* x, double* y, double* z)
{   
    *y = rad * sin(gama);
    double xz = rad * cos(gama);
    *x = xz * cos(teta);
    *z = xz * sin(teta);
}


bool ViewController::Handle(EventListener::EventType etype)
{
    switch (etype)
    {
    case EV_CANCEL:
        mpParent->RemoveEventListener(this);
        return true;
    case EV_TICK:
        return ProcessKey(mLastKey, Engine::KEY_DOWN_EX, 0, 0);        
    }

    return false;
}
    
bool ViewController::ProcessKey(int key, Engine::KeyEvent type, int x, int y)
{
    if (type == Engine::KEY_UP_EX)
    {
        mbKeyInProcessing = false;
        mpParent->RemoveEventListener(this);
        return false;    
    }

    mLastKey = key;
    double vx, vy, vz;
    mpParent->GetViewer(&vx, &vy, &vz);
    
    double xz = pow(vx*vx + vz*vz, 0.5);
    double rad = pow(xz*xz + vy*vy, 0.5);
    double gama = asin(vy/rad);
    double teta = asin(vz/xz);
    if (vx < 0)
        teta = M_PI - teta;
    
    switch (key)
    {
    case GLUT_SPEC_KEY_RIGHT:
        {
            teta = teta - mDeltaAngle;
            if (teta < 0)
                teta = teta + 2 * M_PI;
                
            count_depolar(teta, gama, rad, &vx, &vy, &vz);
            mpParent->SetViewer(vx, vy, vz);
        }        
        break;
    
    case GLUT_SPEC_KEY_UP:
        {
            gama = gama + mDeltaAngle;
            if (gama > M_PI_2)
                gama = M_PI_2;
            
            count_depolar(teta, gama, rad, &vx, &vy, &vz);
            mpParent->SetViewer(vx, vy, vz);
        }
        break;
    
    case GLUT_SPEC_KEY_LEFT:
        {
            teta = teta + mDeltaAngle;
            if (teta > 2 * M_PI) 
                teta = teta - 2 * M_PI;
            
            count_depolar(teta, gama, rad, &vx, &vy, &vz);
            mpParent->SetViewer(vx, vy, vz);
        }
        break;
    
    case GLUT_SPEC_KEY_DOWN:
        {
            gama = gama - mDeltaAngle;
            if (gama < -M_PI_2)
                gama = -M_PI_2;
            
            count_depolar(teta, gama, rad, &vx, &vy, &vz);
            mpParent->SetViewer(vx, vy, vz);
        }
        break;
    
    case 'x':
    case 'X':
        {
            rad = rad - mDeltaDis;
            if (rad < 0)
                rad = 0;
            
            count_depolar(teta, gama, rad, &vx, &vy, &vz);
            mpParent->SetViewer(vx, vy, vz);
        }
        break;
    case 'z':
    case 'Z':
        {
            rad = rad + mDeltaDis;
            if (rad > 30)
                rad = 30;
            
            count_depolar(teta, gama, rad, &vx, &vy, &vz);
            mpParent->SetViewer(vx, vy, vz);
        }
        break;
    default:
        return false;
    }

    if (!mbKeyInProcessing)
    {
        mbKeyInProcessing = true;
        mpParent->AddEventListener(this);
    }
    return true;
}


ViewBongoFollower::ViewBongoFollower(Engine* parent, Bongo* bongo)
: mpParent(parent), mpBongo(bongo)
{
    bongo->RegisterListener(this);
    memcpy(mpParent->mViewCenter, bongo->Position(), 3 * sizeof(double) );
    memcpy(mOldCenter, mpParent->mViewCenter, 3 * sizeof(double) );
    mPower = 0.04;
    mDistance = 0.0;
    memset(mDirection, 0, sizeof(mDirection) );
}

bool ViewBongoFollower::Move()
{ 
    double far1 = mPower;
    if (mDistance == 0)
        return false;

    if (far1 > mDistance)
    {
        vec_mul(mDirection, mDistance/far1);
        far1 = mDistance;   
    }
    vec_add(mpParent->mViewPos, mDirection);
    vec_add(mOldCenter, mDirection);
  
    mDistance -= far1;
    if (0 == mDistance)
    {
        memset(mDirection, 0, sizeof(mDirection) );
    }
    return true;
}

void ViewBongoFollower::QuadEvent()
{
    memcpy(mpParent->mViewCenter, mpBongo->Position(), 3 * sizeof(double) );    

    memcpy(mDirection, mOldCenter, sizeof(mDirection) );    
    vec_mul(mDirection, -1);
    vec_add(mDirection, mpParent->mViewCenter);

    mDistance = vec_magnitude(mDirection);
    vec_mul(mDirection, mPower/mDistance);
}