Make SFCave quick launchable

4 files changed, 21 insertions, 42 deletions

diff --git a/noncore/games/sfcave/opie-sfcave.control b/noncore/games/sfcave/opie-sfcave.control
index 0ff3e2c..1d98a19 100644
--- a/noncore/games/sfcave/opie-sfcave.control
+++ b/noncore/games/sfcave/opie-sfcave.control
@@ -1,9 +1,9 @@
 Package: opie-sfcave
-Files: bin/sfcave apps/Games/sfcave.desktop pics/sfcave
+Files: plugins/applications/libsfcave.so* bin/sfcave apps/Games/sfcave.desktop pics/sfcave
 Priority: optional
 Section: opie/games
 Maintainer: Andy Qua <andy.qua@blueyonder.co.uk>
 Architecture: arm
 Depends: task-opie-minimal
 Description: SFCave for the Zaurus. Fly the dot though the cave avoiding the walls.
 Version: $QPE_VERSION$EXTRAVERSION
diff --git a/noncore/games/sfcave/sfcave.cpp b/noncore/games/sfcave/sfcave.cpp
index 9b30fe6..5dca427 100644
--- a/noncore/games/sfcave/sfcave.cpp
+++ b/noncore/games/sfcave/sfcave.cpp
@@ -1,407 +1,383 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 #include <time.h>
 
-#ifdef QWS
-#include <qpe/qpeapplication.h>
+#include <opie2/oapplicationfactory.h>
 #include <qpe/config.h>
-#else
+
 #include <qapplication.h>
-#endif
 #include <qdir.h>
 
 #include "helpwindow.h"
 #include "sfcave.h"
 
 #define CAPTION "SFCave 1.13 by AndyQ"
 
 #define UP_THRUST               0.6
 #define NO_THRUST               0.8
 #define MAX_DOWN_THRUST         4.0
 #define MAX_UP_THRUST           -3.5
 
 // States
 #define STATE_BOSS              0
 #define STATE_RUNNING           1
 #define STATE_CRASHING          2
 #define STATE_CRASHED           3
 #define STATE_NEWGAME           4
 #define STATE_MENU              5
 #define STATE_REPLAY            6
 
 // Menus
 #define MENU_MAIN_MENU          0
 #define MENU_OPTIONS_MENU       1
 #define MENU_REPLAY_MENU        2
 
 // Main Menu Options
 #define MENU_START_GAME         0
 #define MENU_REPLAY             1
 #define MENU_OPTIONS            2
 #define MENU_HELP               3
 #define MENU_QUIT               4
 
 // Option Menu Options
 #define MENU_GAME_TYPE          0
 #define MENU_GAME_DIFFICULTY    1
 #define MENU_CLEAR_HIGHSCORES   2
 #define MENU_BACK               3
 
 // Replay Menu Options
 #define MENU_REPLAY_START       0
 #define MENU_REPLAY_LOAD        1
 #define MENU_REPLAY_SAVE        2
 #define MENU_REPLAY_BACK        3
 
 
 #define NR_GAME_DIFFICULTIES    3
 #define NR_GAME_TYPES           3
 
 #define DIFICULTY_EASY          0
 #define DIFICULTY_NORMAL        1
 #define DIFICULTY_HARD          2
 #define EASY                    "Easy"
 #define NORMAL                  "Normal"
 #define HARD                    "Hard"
 
 #define SFCAVE_GAME_TYPE        0
 #define GATES_GAME_TYPE         1
 #define FLY_GAME_TYPE           2
 #define SFCAVE_GAME             "SFCave"
 #define GATES_GAME              "Gates"
 #define FLY_GAME                "Fly"
 #define CURRENT_GAME_TYPE       gameTypes[currentGameType]
 #define CURRENT_GAME_DIFFICULTY difficultyOption[currentGameDifficulty];
 
 QString SFCave::dificultyOption[] = { EASY, NORMAL, HARD };
 QString SFCave::gameTypes[] = { SFCAVE_GAME, GATES_GAME, FLY_GAME };
 
 QString SFCave::menuOptions[NR_MENUS][MAX_MENU_OPTIONS] = { { "Start Game", "Replays", "Options", "Help", "Quit", "", "", "" },
                                     { "Game Type - %s", "Game Difficulty - %s", "Clear High Scores for this game", "Back", "", "", "", "" },
                                     { "Play Reply", "Load Replay", "Save Replay", "Back", "", "", "", "" } };
 
 int SFCave::nrMenuOptions[NR_MENUS] = { 5, 4, 4 };
 int SFCave ::currentMenuOption[NR_MENUS] = { 0, 0, 0 };
                                     
 #define UP_THRUST               0.6
 #define NO_THRUST               0.8
 #define MAX_DOWN_THRUST         4.0
 #define MAX_UP_THRUST           -3.5
 double SFCave::UpThrustVals[3][3]               = {{ 0.6,   0.6, 0.6 },     // SFCave
                                                    { 0.6,   0.6, 0.8 },     // Gates
                                                    { 0.4,   0.7, 1.0 } };   // Fly
                                                    
 double SFCave::DownThrustVals[3][3]             = {{ 0.8,   0.8, 0.8 },     // SFCave
                                                    { 0.8,   0.8, 1.0 },     // Gates
                                                    { 0.4,   0.7, 1.0 } };   // Fly
                                                    
 double SFCave::MaxUpThrustVals[3][3]            = {{ -3.5, -3.5, -3.5 },    // SFCave
                                                    { -3.5, -4.0, -5.0 },    // Gates
                                                    { -3.5, -4.0, -5.0 } };  // Fly
                                                    
 double SFCave::MaxDownThrustVals[3][3]          = {{ 4.0,   4.0, 4.0 },     // SFCave
                                                    { 4.0,   5.0, 5.5 },     // Gates
                                                    { 3.5,   4.0, 5.0 } };   // Fly
 
 int SFCave::flyEasyScores[7][3] = { { 0, 10, 5 },
                                    { 10, 20, 3 },
                                    { 20, 30, 2 },
                                    { 30, 40, 1 },
                                    { 50, 70, -2 },
                                    { 70, 300, -5 },
                                    { -1, -1, -1 } };
 int SFCave::flyNormalScores[7][3] = { { 0, 10, 5 },
                                      { 10, 20, 3 },
                                      { 20, 30, 2 },
                                      { 30, 40, 1 },
                                      { 50, 70, -2 },
                                      { 70, 300, -5 },
                                      { -1, -1, -1 } };
 int SFCave::flyHardScores[7][3] = { { 0, 20, 5 },
                                    { 20, 40, 3 },
                                    { 40, 100, 1 },
                                    { 100, 150, -2 },
                                    { 150, 300, -5 },
                                    { -1, -1, -1 } };
 
 int SFCave::initialGateGaps[]           = { 75, 50, 25 };
 
 
 #define FLYSCORES( x, y )  (*(flyScores + ((x)*3) + y))
 bool movel;
 
 
-int main( int argc, char *argv[] )
-{
-    movel = true;
-#ifdef QWS
-    QPEApplication a( argc, argv );
-#else
-    QApplication a( argc, argv );
-#endif
+OPIE_EXPORT_APP( Opie::Core::OApplicationFactory<SFCave> )
 
-    int speed = 3;
-    for ( int i = 0 ; i < argc ; ++i )
-    {
-        if ( strcmp( argv[i], "-s" ) == 0 )
-        {
-            if ( i+1 < argc )
-                speed = atoi( argv[i+1] );
-        }
-    }
-
-    SFCave app( speed );
-    a.setMainWidget( &app );
-    app.show();
-    app.start();
-    a.exec();
-}
-
-SFCave :: SFCave( int spd, QWidget *w, char *name )
-    : QMainWindow( w, name )
+SFCave :: SFCave( QWidget *w, const char *name, WFlags fl )
+    : QMainWindow( w, name, fl )
 
 {
-    replayIt = 0;
-#ifdef QWS
     showMaximized();
-#else
-    resize( 240, 284 );
-#endif
+    movel = true;
+    int spd = 3;
+    
+    
+    replayIt = 0;
 
     replayFile = QDir::home().path();
     replayFile += "/sfcave.replay";
     printf( "%s\n", (const char *)replayFile );
 
     sWidth = width();
     sHeight = height();
     segSize = sWidth/(MAPSIZE-1)+1;
 
     currentMenuNr = 0;
     currentGameType = 0;
     currentGameDifficulty = 0;
 
     setCaption( CAPTION );
     showScoreZones = false;
 
 #ifdef QWS
     Config cfg( "sfcave" );
     cfg.setGroup( "settings" );
     QString key = "highScore_";
 
     for ( int i = 0 ; i < 3 ; ++i )
     {
         for ( int j = 0 ; j < 3 ; ++j )
             highestScore[i][j] = cfg.readNumEntry( key + gameTypes[i] + "_" + dificultyOption[j], 0 );
     }
     
     currentGameType = cfg.readNumEntry( "gameType", 0 );
     currentGameDifficulty = cfg.readNumEntry( "difficulty", 0 );
 #endif
     speed = spd; // Change to 2 for PC
     press = false;
     showEyeCandy = false;
 
     offscreen = new QPixmap( sWidth, sHeight );
     offscreen->fill( Qt::black );
 
 //    setUp();
     crashLineLength = -1;
     state = STATE_MENU;
     prevState = STATE_MENU;
 
     gameTimer = new QTimer( this, "game timer" );
     connect( gameTimer, SIGNAL( timeout() ),
              this, SLOT( run() ) );
+             
+    QTimer::singleShot(0, this, SLOT(start()));
 }
 
 SFCave :: ~SFCave()
 {
 }
 
 void SFCave :: start()
 {
     gameTimer->start( 10 );
 
 }
 
 void SFCave :: setSeed( int seed )
 {
     if ( seed == -1 )
         currentSeed = ((unsigned long) time((time_t *) NULL));
     else
         currentSeed = seed;
     PutSeed( currentSeed );
 }
     
 int SFCave :: nextInt( int range )
 {
     int val = (int)(Random( ) * range);
 
     return val;
     
 }
 
 void SFCave :: setUp()
 {
     score = 0;
     offset = 0;
     nrFrames = 0;
     dir = 1;
     thrust = 0;
     startScoring = false;
     press = false;
 
     if ( CURRENT_GAME_TYPE == SFCAVE_GAME )
     {
         thrustUp = UpThrustVals[SFCAVE_GAME_TYPE][currentGameDifficulty];;
         noThrust = DownThrustVals[SFCAVE_GAME_TYPE][currentGameDifficulty];;
         maxUpThrust = MaxUpThrustVals[SFCAVE_GAME_TYPE][currentGameDifficulty];;
         maxDownThrust = MaxDownThrustVals[SFCAVE_GAME_TYPE][currentGameDifficulty];;
 
         if ( currentGameDifficulty == DIFICULTY_EASY )
             gateDistance = 100;
         else if ( currentGameDifficulty == DIFICULTY_NORMAL )
             gateDistance = 60;
         else
             gateDistance = 40;
     }
     else if ( CURRENT_GAME_TYPE == GATES_GAME )
     {
         thrustUp = UpThrustVals[GATES_GAME_TYPE][currentGameDifficulty];;
         noThrust = DownThrustVals[GATES_GAME_TYPE][currentGameDifficulty];;
         maxUpThrust = MaxUpThrustVals[GATES_GAME_TYPE][currentGameDifficulty];;
         maxDownThrust = MaxDownThrustVals[GATES_GAME_TYPE][currentGameDifficulty];;
         gateDistance = 75;
         nextGate = nextInt( 50 ) + gateDistance;
     }
     else
     {
         thrustUp = UpThrustVals[FLY_GAME_TYPE][currentGameDifficulty];
         noThrust = DownThrustVals[FLY_GAME_TYPE][currentGameDifficulty];
         maxUpThrust = MaxUpThrustVals[FLY_GAME_TYPE][currentGameDifficulty];
         maxDownThrust = MaxDownThrustVals[FLY_GAME_TYPE][currentGameDifficulty];
 
         if ( currentGameDifficulty == DIFICULTY_EASY )
             flyScores = (int*)flyEasyScores;
         else if ( currentGameDifficulty == DIFICULTY_NORMAL )
             flyScores = (int*)flyNormalScores;
         else
             flyScores = (int*)flyHardScores;
     }
     
     crashLineLength = 0;
     lastGateBottomY = 0;
 
     user.setRect( 50, sWidth/2, 4, 4 );
 
     blockWidth = 20;
     blockHeight = 70;
     gapHeight = initialGateGaps[currentGameDifficulty];
 
     for ( int i = 0 ; i < TRAILSIZE ; ++i )
     {
         trail[i].setX( -1 );
         trail[i].setY( 0 );
     }
 
     if ( CURRENT_GAME_TYPE != FLY_GAME )
     {
         maxHeight = 50;
         
         mapTop[0] = (int)(nextInt(50)) + 5;
         mapBottom[0] = (int)(nextInt(50)) + 5;
         for ( int i = 1 ; i < MAPSIZE ; ++i )
             setPoint( i );
     }
     else
     {
         maxHeight = 100;
 
         for ( int i = 0 ; i < MAPSIZE ; ++i )
             mapBottom[i] = sHeight - 10;
     }
     for ( int i = 0 ; i < BLOCKSIZE ; ++i )
         blocks[i].setY( -1 );
 
 }
 
 void SFCave :: run()
 {
     switch ( state )
     {
         case STATE_MENU:
             displayMenu();
             break;
         case STATE_NEWGAME:
             setSeed( -1 );
             setUp();
             draw();
             state = STATE_RUNNING;
             replay = false;
             replayList.clear();
             break;
         case STATE_REPLAY:
             setSeed( currentSeed );
             setUp();
             draw();
             state = STATE_RUNNING;
             replay = true;
             if ( replayIt )
                 delete replayIt;
             replayIt = new QListIterator<int>( replayList );
             break;
         case STATE_BOSS:
             drawBoss();
             break;
 
         case STATE_CRASHING:
         case STATE_CRASHED:
             press = false;
             draw();
             break;
 
         case STATE_RUNNING:
         {
             if ( nrFrames % 2 == 0 )
                 handleKeys();
 
             // Apply Game rules
             nrFrames ++;
 
             if ( replay )
             {
                 while( replayIt->current() && *(replayIt->current()) == nrFrames )
                 {
                     press = !press;
                     ++(*replayIt);
                 }
             }
             
             if ( CURRENT_GAME_TYPE == SFCAVE_GAME )
                 handleGameSFCave();
             else if ( CURRENT_GAME_TYPE == GATES_GAME )
                 handleGameGates();
             else if ( CURRENT_GAME_TYPE == FLY_GAME )
                 handleGameFly();
 
             draw();
             break;
         }
     }
 }
 
 void SFCave :: handleGameSFCave()
 {
     // Update score
     if ( nrFrames % 5 == 0 )
         score ++;
 
     if ( nrFrames % 500 == 0 )
     {
         if ( maxHeight < sHeight - 100 )
         {
             maxHeight += 10;
 
             // Reduce block height
             if ( maxHeight > sHeight - 150 )
diff --git a/noncore/games/sfcave/sfcave.h b/noncore/games/sfcave/sfcave.h
index b1fe819..7bdf881 100644
--- a/noncore/games/sfcave/sfcave.h
+++ b/noncore/games/sfcave/sfcave.h
@@ -1,131 +1,137 @@
 #include <qmainwindow.h>
 #include <qpainter.h>
 #include <qpixmap.h>
 #include <qpoint.h>
 #include <qrect.h>
 #include <qtimer.h>
 #include <qlist.h>
 
 #include "random.h"
 
 #define MAPSIZE 52
 #define BLOCKSIZE 6
 #define TRAILSIZE 30
 
 #define NR_MENUS    3
 #define MAX_MENU_OPTIONS 8
 
 class SFCave : public QMainWindow
 {
 Q_OBJECT
 
 public:
         int sWidth;
         int sHeight;
         int segSize;
 
     int currentSeed;
 
     QList<int> replayList;
     QListIterator<int> *replayIt;
     bool replay;
     QString replayFile;
 
         int blockWidth;
         int blockHeight;
     int gapHeight;
         int state;
         int prevState;
         int speed;
     int crashLineLength;
     bool startScoring;
     bool showEyeCandy;
 
     static double UpThrustVals[3][3];
     static double DownThrustVals[3][3];
     static double MaxUpThrustVals[3][3];
     static double MaxDownThrustVals[3][3];
     static int initialGateGaps[];
 
     static int flyEasyScores[7][3];
     static int flyNormalScores[7][3];
     static int flyHardScores[7][3];
     int *flyScores;
 
     
     double thrustUp;
     double noThrust;
     double maxUpThrust;
     double maxDownThrust;
 
     int gateDistance;
     int nextGate;
     int lastGateBottomY;
     
     static QString menuOptions[NR_MENUS][MAX_MENU_OPTIONS];
     int currentMenuNr;
     static int nrMenuOptions[NR_MENUS];
     static int currentMenuOption[NR_MENUS];
 
     static QString dificultyOption[3];
     static QString gameTypes[3];
     int currentGameType;
     int currentGameDifficulty;
 
         QPixmap *offscreen;
         QTimer *gameTimer;
 
         int score;
         int highestScore[3][3];
 
         int mapTop[MAPSIZE];
         int mapBottom[MAPSIZE];
         QRect blocks[BLOCKSIZE];
         QRect user;
         QPoint trail[TRAILSIZE];
 
         int offset;
         int maxHeight;
         int nrFrames;
         int dir;
 
         bool showScoreZones;
 
         bool press;
         double thrust;
         bool running;
 
-        SFCave( int speed = 3, QWidget *p = 0, char *name = 0 );
+        SFCave( QWidget *p = 0, const char *name = 0, WFlags fl = 0 );
         ~SFCave();
+
+        static QString appName() { return QString::fromLatin1( QUICKAPP_NAME ); }
+        
+public slots:
         void start();
+public:
+        
     void setSeed( int seed );
         int nextInt( int range );
         void setUp();
     void handleGameSFCave();
     void handleGameGates();
     void handleGameFly();
         bool checkFlyGameCollision();
         void moveFlyGameLandscape();
         void setFlyPoint( int point );
         bool checkCollision();
         void moveLandscape();
         void addBlock();
         void addGate();
         void setPoint( int point );
         void drawBoss();
         void draw();
         void handleKeys();
 
     void handleMenuKeys( QKeyEvent * e );
     void displayMenu();
     void dealWithMenuSelection();
 
         void keyPressEvent( QKeyEvent *e );
         void keyReleaseEvent( QKeyEvent *e );
     void saveScore();
     void saveReplay();
     void loadReplay();
 
 private slots:
         void run();
 };
diff --git a/noncore/games/sfcave/sfcave.pro b/noncore/games/sfcave/sfcave.pro
index a0df828..3a26a79 100644
--- a/noncore/games/sfcave/sfcave.pro
+++ b/noncore/games/sfcave/sfcave.pro
@@ -1,13 +1,10 @@
-        TEMPLATE= app
-        CONFIG  += qt warn_on 
-        DESTDIR         = $(OPIEDIR)/bin
+        CONFIG  += qt  quick-app
         SOURCES = sfcave.cpp helpwindow.cpp random.cpp
         HEADERS = sfcave.h helpwindow.h random.h
         TARGET  = sfcave
         INCLUDEPATH += $(OPIEDIR)/include
         DEPENDPATH+= $(OPIEDIR)/include
 LIBS            += -lqpe
 
 
-
 include ( $(OPIEDIR)/include.pro )