1 files changed, 7 insertions, 8 deletions

diff --git a/noncore/games/sfcave/sfcave.cpp b/noncore/games/sfcave/sfcave.cpp
index 5dca427..d5aa38a 100644
--- a/noncore/games/sfcave/sfcave.cpp
+++ b/noncore/games/sfcave/sfcave.cpp
@@ -1,71 +1,72 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 #include <time.h>
 
 #include <opie2/oapplicationfactory.h>
 #include <qpe/config.h>
+#include <qpe/global.h>
 
 #include <qapplication.h>
 #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"
@@ -82,131 +83,129 @@ QString SFCave::menuOptions[NR_MENUS][MAX_MENU_OPTIONS] = { { "Start Game", "Rep
 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;
 
 
 OPIE_EXPORT_APP( Opie::Core::OApplicationFactory<SFCave> )
 
 SFCave :: SFCave( QWidget *w, const char *name, WFlags fl )
     : QMainWindow( w, name, fl )
 
 {
     showMaximized();
     movel = true;
     int spd = 3;
     
     
     replayIt = 0;
 
-    replayFile = QDir::home().path();
-    replayFile += "/sfcave.replay";
-    printf( "%s\n", (const char *)replayFile );
+    replayFile = Global::applicationFileName("sfcave", "replay");
 
     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 );
 }
     
@@ -863,208 +862,208 @@ void SFCave :: keyReleaseEvent( QKeyEvent *e )
     {
         switch( e->key() )
         {
             case Qt::Key_F9:
             case Qt::Key_Space:
             case Qt::Key_Up:
                 if ( state == STATE_RUNNING )
                 {
                     if ( !replay && press )
                     {
                         press = false;
                         replayList.append( new int( nrFrames ) );
                     }
                 }
                 break;
 
             case Qt::Key_E:
                 showEyeCandy = !showEyeCandy;
                 break;
                 
             case Qt::Key_R:
                 if ( state == STATE_CRASHED )
                     state = STATE_REPLAY;
                 break;
 
             case Qt::Key_Down:
                 if ( state == STATE_CRASHED )
                     state = STATE_NEWGAME;
                 break;
 
             case Qt::Key_S:
                 if ( state == STATE_CRASHED )
                     saveReplay();
                 break;
 
             case Qt::Key_L:
                 if ( state == STATE_CRASHED )
                     loadReplay();
                 break;
            default:
                 e->ignore();
                 break;
         }
     }
 
 }
 
 
 void SFCave :: saveScore()
 {
 #ifdef QWS
     Config cfg( "sfcave" );
     cfg.setGroup( "settings" );
     QString key = "highScore_";
 
     cfg.writeEntry( key + gameTypes[currentGameType] + "_" + dificultyOption[currentGameDifficulty], highestScore[currentGameType][currentGameDifficulty] );
     key += CURRENT_GAME_TYPE;
     cfg.writeEntry( key, highestScore[currentGameType] );
 #endif
 }
 
 void SFCave :: saveReplay()
 {
     FILE *out;
-    out = fopen( (const char *)replayFile, "w" );
+    out = fopen( QFile::encodeName(replayFile).data(), "w" );
     if ( !out )
     {
-        printf( "Couldn't write to /home/root/sfcave.replay\n" );
+        printf( "Couldn't write to %s\n", QFile::encodeName(replayFile).data() );
         return;
     }
 
     // Build up string of values
     // Format is:: <landscape seed> <game type> <difficulty> <framenr> <framenr>.......
     QString val;
     val.sprintf( "%d %d %d ", currentSeed, currentGameType, currentGameDifficulty );
     
     QListIterator<int> it( replayList );
     while( it.current() )
     {
         QString tmp;
         tmp.sprintf( "%d ", (*it.current()) );
         val += tmp;
 
         ++it;
     }
     val += "\n";
 
     QString line;
     line.sprintf( "%d\n", val.length() );
     fwrite( (const char *)line, 1, line.length(), out );
 
     fwrite( (const char *)val, 1, val.length(), out );
    
     fclose( out );
 
-    printf( "Replay saved to %s\n", (const char *)replayFile );
+    printf( "Replay saved to %s\n", QFile::encodeName(replayFile).data() );
 
 }
 
 void SFCave :: loadReplay()
 {
-    FILE *in = fopen( (const char *)replayFile, "r" );
+    FILE *in = fopen( QFile::encodeName(replayFile).data() , "r" );
 
     if ( in == 0 )
     {
         printf( "Couldn't load replay file!\n" );
         return;
     }   
 
     // Read next line - contains the size of the options
     char line[10+1];
     fgets( line, 10, in );
 
     int length = -1;
     sscanf( line, "%d", &length );
     char *data = new char[length+1];
 
     fread( data, 1, length, in );
 //    printf( "data - %s", data );
 
     QString sep  = " ";
     QStringList list = QStringList::split( sep, QString( data ) );
     
     // print it out
     QStringList::Iterator it = list.begin();
     currentSeed = (*it).toInt();
     ++it;
     currentGameType = (*it).toInt();
     ++it;
     currentGameDifficulty = (*it).toInt();
     ++it;
 
     replayList.clear();
     for ( ; it != list.end(); ++it )
     {
         int v = (*it).toInt();
         replayList.append( new int( v ) );
     }
 
     delete data;
 
     fclose( in );
     
-    printf( "Replay loaded from %s\n", (const char *)replayFile );
+    printf( "Replay loaded from %s\n", QFile::encodeName(replayFile).data() );
 }
 
 
 //--------------- MENU CODE ---------------------
 void SFCave :: handleMenuKeys( QKeyEvent *e )
 {
     switch( e->key() )
     {
         case Qt::Key_Down:
             currentMenuOption[currentMenuNr] ++;
             if ( menuOptions[currentMenuNr][currentMenuOption[currentMenuNr]] == "" )
                 currentMenuOption[currentMenuNr] = 0;
             break;
         case Qt::Key_Up:
             currentMenuOption[currentMenuNr] --;
             if ( currentMenuOption[currentMenuNr] < 0 )
                 currentMenuOption[currentMenuNr] = nrMenuOptions[currentMenuNr]-1;
             break;
 
         case Qt::Key_Left:
             if ( currentMenuNr == MENU_OPTIONS_MENU )
             {
                 if ( currentMenuOption[currentMenuNr] == MENU_GAME_TYPE )
                 {
                     currentGameType --;
                     if ( currentGameType < 0 )
                         currentGameType = NR_GAME_TYPES - 1;
                 }
                 else if ( currentMenuOption[currentMenuNr] == MENU_GAME_DIFFICULTY )
                 {
                     currentGameDifficulty --;
                     if ( currentGameDifficulty < 0 )
                         currentGameDifficulty = NR_GAME_DIFFICULTIES - 1;
                 }
             }
             break;
 
         case Qt::Key_Right:
             if ( currentMenuNr == MENU_OPTIONS_MENU )
             {
                 if ( currentMenuOption[currentMenuNr] == MENU_GAME_TYPE )
                 {
                     currentGameType ++;
                     if ( currentGameType == NR_GAME_TYPES )
                         currentGameType = 0;
                 }
                 else if ( currentMenuOption[currentMenuNr] == MENU_GAME_DIFFICULTY )
                 {
                     currentGameDifficulty ++;
                     if ( currentGameDifficulty == NR_GAME_DIFFICULTIES )
                         currentGameDifficulty = 0;
                 }
             }
             break;
 
         case Qt::Key_Space:
         case Qt::Key_Return:
         case Qt::Key_Enter:
             dealWithMenuSelection();
             break;
     }
 }
 
 void SFCave :: displayMenu()