summaryrefslogtreecommitdiff
Side-by-side diff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--noncore/games/sfcave/sfcave.cpp19
-rw-r--r--noncore/games/sfcave/sfcave.h2
2 files changed, 11 insertions, 10 deletions
diff --git a/noncore/games/sfcave/sfcave.cpp b/noncore/games/sfcave/sfcave.cpp
index d6d28b2..9b30fe6 100644
--- a/noncore/games/sfcave/sfcave.cpp
+++ b/noncore/games/sfcave/sfcave.cpp
@@ -1,1236 +1,1237 @@
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#ifdef QWS
#include <qpe/qpeapplication.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
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 )
{
replayIt = 0;
#ifdef QWS
showMaximized();
#else
resize( 240, 284 );
#endif
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() ) );
}
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 = flyEasyScores;
+ flyScores = (int*)flyEasyScores;
else if ( currentGameDifficulty == DIFICULTY_NORMAL )
- flyScores = flyNormalScores;
+ flyScores = (int*)flyNormalScores;
else
- flyScores = flyHardScores;
+ 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 )
blockHeight -= 5;
}
}
if ( nrFrames % gateDistance == 0 )
addBlock();
if ( checkCollision() )
{
if ( score > highestScore[currentGameType][currentGameDifficulty] )
{
highestScore[currentGameType][currentGameDifficulty] = score;
saveScore();
}
state = STATE_CRASHING;
}
else
{
moveLandscape();
}
}
void SFCave :: handleGameGates()
{
// Update score
if ( nrFrames % 5 == 0 )
score ++;
// Slightly random gap distance
if ( nrFrames >= nextGate )
{
nextGate = nrFrames + nextInt( 50 ) + gateDistance;
addGate();
}
if ( nrFrames % 500 == 0 )
{
if ( gapHeight > 75 )
gapHeight -= 5;
}
if ( checkCollision() )
{
if ( score > highestScore[currentGameType][currentGameDifficulty] )
{
highestScore[currentGameType][currentGameDifficulty] = score;
saveScore();
}
state = STATE_CRASHING;
}
else
{
moveLandscape();
}
}
void SFCave :: handleGameFly()
{
int diff = mapBottom[10] - user.y();
if ( nrFrames % 4 == 0 )
{
if ( !startScoring )
{
if ( diff < 40 )
startScoring = true;
}
if ( startScoring )
{
// Update score
// get distance between landscape and ship
// the closer the difference is to 0 means more points
- for ( int i = 0 ; i < 10 && flyScores[i][0] != -1 ; ++i )
+ for ( int i = 0 ; i < 10 && FLYSCORES( i, 0 ) != -1 ; ++i )
{
- if ( flyScores[i][0] <= diff && flyScores[i][1] > diff )
+ if ( FLYSCORES( i, 0 ) <= diff && FLYSCORES(i, 1 ) > diff )
{
- score += flyScores[i][2];
+ score += FLYSCORES( i, 2 );
break;
}
}
}
}
if ( checkFlyGameCollision() )
{
if ( score > highestScore[currentGameType][currentGameDifficulty] )
{
highestScore[currentGameType][currentGameDifficulty] = score;
saveScore();
}
state = STATE_CRASHING;
}
else
{
moveFlyGameLandscape();
}
}
bool SFCave :: checkFlyGameCollision()
{
if ( (user.y() + user.width()) >= mapBottom[11] )
return true;
return false;
}
void SFCave :: moveFlyGameLandscape()
{
offset++;
if ( offset >= segSize )
{
offset = 0;
for ( int i = 0 ; i < MAPSIZE-speed ; ++i )
mapBottom[i] = mapBottom[i+speed];
for ( int i = speed ; i > 0 ; --i )
setFlyPoint( MAPSIZE-i );
}
}
void SFCave :: setFlyPoint( int point )
{
static int fly_difficulty_levels[] = { 5, 10, 15 };
if ( nextInt(100) >= 75 )
dir *= -1;
int prevPoint = mapBottom[point-1];
int nextPoint = prevPoint + (dir * nextInt( fly_difficulty_levels[currentGameDifficulty] ) );
if ( nextPoint > sHeight )
{
nextPoint = sHeight;
dir *= -1;
}
else if ( nextPoint < maxHeight )
{
nextPoint = maxHeight;
dir *= 1;
}
mapBottom[point] = nextPoint;
}
bool SFCave :: checkCollision()
{
if ( (user.y() + user.width()) >= mapBottom[11] || user.y() <= mapTop[11] )
return true;
for ( int i = 0 ; i < BLOCKSIZE ; ++i )
{
if ( blocks[i].y() != -1 )
{
if ( blocks[i].intersects( user ) )
return true;
}
}
return false;
}
void SFCave :: moveLandscape()
{
offset++;
if ( offset >= segSize )
{
offset = 0;
for ( int i = 0 ; i < MAPSIZE-speed ; ++i )
{
mapTop[i] = mapTop[i+speed];
mapBottom[i] = mapBottom[i+speed];
}
for ( int i = speed ; i > 0 ; --i )
setPoint( MAPSIZE-i );
}
for ( int i = 0 ; i < BLOCKSIZE ; ++i )
{
if ( blocks[i].y() != -1 )
{
blocks[i].moveBy( -speed, 0 );
if ( blocks[i].x() + blocks[i].width() < 0 )
blocks[i].setY( -1 );
}
}
}
void SFCave :: addBlock()
{
for ( int i = 0 ; i < BLOCKSIZE ; ++i )
{
if ( blocks[i].y() == -1 )
{
int x = sWidth;
int y = mapTop[50] + (int)(nextInt(mapBottom[50] - mapTop[50] - blockHeight));
blocks[i].setRect( x, y, blockWidth, blockHeight );
break;
}
}
}
void SFCave :: addGate()
{
for ( int i = 0 ; i < BLOCKSIZE ; ++i )
{
if ( blocks[i].y() == -1 )
{
int x1 = sWidth;
int y1 = mapTop[50];
int b1Height = nextInt(mapBottom[50] - mapTop[50] - gapHeight);
// See if height between last gate and this one is too big
if ( b1Height - 100 > lastGateBottomY )
b1Height -= 25;
else if ( b1Height + 100 < lastGateBottomY )
b1Height += 25;
lastGateBottomY = b1Height;
int x2 = sWidth;
int y2 = y1 + b1Height + gapHeight;
int b2Height = mapBottom[50] - y2;
blocks[i].setRect( x1, y1, blockWidth, b1Height );
blocks[i+1].setRect( x2, y2, blockWidth, b2Height );
break;
}
}
}
void SFCave :: setPoint( int point )
{
if ( nextInt(100) >= 80 )
dir *= -1;
mapTop[point] = mapTop[point-1] + (dir * nextInt( 5 ) );
if ( mapTop[point] < 0 )
{
mapTop[point] = 0;
dir *= -1;
}
else if ( mapTop[point] >= maxHeight )
{
mapTop[point] = maxHeight;
dir *= -1;
}
// mapBottom[point] = sHeight - (maxHeight - mapBottom[point]);
mapBottom[point] = sHeight - (maxHeight - mapTop[point]);
}
void SFCave :: drawBoss()
{
offscreen->fill( Qt::black );
bitBlt( this, 0, 0, offscreen, 0, 0, sWidth, sHeight, Qt::CopyROP, true );
}
void SFCave :: draw()
{
//printf( "Paint\n" );
offscreen->fill( Qt::black );
QPainter p( offscreen );
QFontMetrics fm = p.fontMetrics();
p.setPen( Qt::white );
for ( int i = 0 ; i < MAPSIZE -3; ++i )
{
// Only display top landscape if not running FLY_GAME
if ( CURRENT_GAME_TYPE != FLY_GAME )
p.drawLine( (i*segSize) - (offset*speed), mapTop[i], ((i+1)*segSize)-(offset*speed), mapTop[i+1] );
p.drawLine( (i*segSize) - (offset*speed), mapBottom[i], ((i+1)*segSize)-(offset*speed), mapBottom[i+1] );
if ( CURRENT_GAME_TYPE == FLY_GAME && showScoreZones )
{
p.setPen( Qt::blue );
- for ( int j = 1 ; j < 10 && flyScores[j][0] != -1 ; ++j )
+ for ( int j = 1 ; j < 10 && FLYSCORES( j, 0 ) != -1 ; ++j )
{
- if ( flyScores[j][2] < 0 )
+ if ( FLYSCORES( j, 2 ) < 0 )
p.setPen( Qt::red );
- p.drawLine( (i*segSize) - (offset*speed), mapBottom[i]-flyScores[j][0], ((i+1)*segSize)-(offset*speed), mapBottom[i+1]-flyScores[j][0] );
+ p.drawLine( (i*segSize) - (offset*speed), mapBottom[i]-FLYSCORES( j, 0 ), ((i+1)*segSize)-(offset*speed), mapBottom[i+1]-FLYSCORES( j, 0 ) );
}
p.setPen( Qt::white );
}
}
// Uncomment this to show user segment (usful for checking collision boundary with landscape
// p.setPen( Qt::red );
// p.drawLine( (11*segSize) - (offset*speed), 0, ((11)*segSize)-(offset*speed), sHeight );
// p.setPen( Qt::white );
// Draw user
p.drawRect( user );
// Draw trails
for ( int i = 0 ; i < TRAILSIZE ; ++i )
if ( trail[i].x() >= 0 )
{
if ( showEyeCandy )
p.setPen( Qt::white.light((int)(100.0-3*(user.x()/100.0)* (user.x()-trail[i].x())) ) );
p.drawRect( trail[i].x(), trail[i].y(), 2, 2 );
}
p.setPen( Qt::white );
// Draw blocks
for ( int i = 0 ; i < BLOCKSIZE ; ++i )
if ( blocks[i].y() != -1 )
{
p.fillRect( blocks[i], Qt::black );
p.drawRect( blocks[i] );
}
// draw score
QString s;
s.sprintf( "score %06d high score %06d", score, highestScore[currentGameType][currentGameDifficulty] );
p.drawText( 5, 10, s );
if ( state == STATE_CRASHING || state == STATE_CRASHED )
{
// add next crash line
if ( crashLineLength != -1 )
{
for ( int i = 0 ; i < 36 ; ++i )
{
int x = (int)(user.x() + (crashLineLength+nextInt(10)) * cos( (M_PI/180) * (10.0 * i) ) );
int y = (int)(user.y() + (crashLineLength+nextInt(10)) * sin( (M_PI/180) * (10.0 * i) ) ); p.drawLine( user.x(), user.y(), x, y );
}
}
if ( state == STATE_CRASHING && crashLineLength >= 15 ) //|| crashLineLength == -1) )
state = STATE_CRASHED;
if ( state == STATE_CRASHED )
{
QString text = "Press up or down to start";
p.drawText( (sWidth/2) - (fm.width( text )/2), 120, text );
text = "Press OK for menu";
p.drawText( (sWidth/2) - (fm.width( text )/2), 135, text );
/*
text = "Press r to replay";
p.drawText( (sWidth/2) - (fm.width( text )/2), 150, text );
text = "Press s to save the replay";
p.drawText( (sWidth/2) - (fm.width( text )/2), 165, text );
text = "Press r to load a saved replay";
p.drawText( (sWidth/2) - (fm.width( text )/2), 180, text );
*/
}
else
crashLineLength ++;
}
p.end();
bitBlt( this, 0, 0, offscreen, 0, 0, sWidth, sHeight, Qt::CopyROP, true );
//printf( "endpaint\n" );
}
void SFCave :: handleKeys()
{
// Find enpty trail and move others
bool done = false;
for ( int i = 0 ; i < TRAILSIZE ; ++i )
{
if ( trail[i].x() < 0 )
{
if ( !done )
{
trail[i].setX( user.x() - 5 );
trail[i].setY( user.y() );
done = true;
}
}
else
{
trail[i].setX( trail[i].x() - (2) );
}
}
if ( speed <= 3 )
{
if ( press )
thrust -= thrustUp;
else
thrust += noThrust;
if ( thrust > maxDownThrust )
thrust = maxDownThrust;
else if ( thrust < maxUpThrust )
thrust = maxUpThrust;
}
else
{
if ( press )
thrust -= 0.5;
else
thrust += 0.8;
if ( thrust > 5.0 )
thrust = 5.0;
else if ( thrust < -3.5 )
thrust = -3.5;
}
user.moveBy( 0, (int)thrust );
}
void SFCave :: keyPressEvent( QKeyEvent *e )
{
if ( state == STATE_MENU )
handleMenuKeys( e );
else
{
switch( e->key() )
{
case Qt::Key_Up:
case Qt::Key_F9:
case Qt::Key_Space:
if ( state == STATE_RUNNING )
{
if ( !replay && !press )
{
press = true;
replayList.append( new int( nrFrames ) );
}
}
else if ( state == STATE_CRASHED )
{
if ( e->key() == Key_Up )
state = STATE_NEWGAME;
}
break;
case Qt::Key_M:
case Qt::Key_Return:
case Qt::Key_Enter:
if ( state == STATE_CRASHED )
{
state = STATE_MENU;
currentMenuNr = 0;
currentMenuOption[currentMenuNr] = 0;
}
break;
case Qt::Key_Z:
showScoreZones = !showScoreZones;
break;
default:
e->ignore();
break;
}
}
}
void SFCave :: keyReleaseEvent( QKeyEvent *e )
{
if ( state == STATE_MENU )
{
}
else
{
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" );
if ( !out )
{
printf( "Couldn't write to /home/root/sfcave.replay\n" );
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 );
}
void SFCave :: loadReplay()
{
FILE *in = fopen( (const char *)replayFile, "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 );
}
//--------------- 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()
{
offscreen->fill( Qt::black );
QPainter p( offscreen );
p.setPen( Qt::white );
QFont f( "Helvetica", 16 );
p.setFont( f );
QFontMetrics fm = p.fontMetrics();
QString text = "SFCave";
p.drawText( (sWidth/2) - (fm.width( text )/2), 60, text );
text = "Written by Andy Qua";
p.drawText( (sWidth/2) - (fm.width( text )/2), 85, text );
// Draw options
int pos = 140;
for ( int i = 0 ; menuOptions[currentMenuNr][i] != "" ; ++i, pos += 25 )
{
if ( currentMenuOption[currentMenuNr] == i )
p.setPen( Qt::yellow );
else
p.setPen( Qt::white );
QString text;
if ( menuOptions[currentMenuNr][i].find( "%s" ) != -1 )
{
QString val;
if ( i == MENU_GAME_TYPE )
val = gameTypes[currentGameType];
else
val = dificultyOption[currentGameDifficulty];
text.sprintf( (const char *)menuOptions[currentMenuNr][i], (const char *)val );
}
else
text = menuOptions[currentMenuNr][i];
p.drawText( (sWidth/2) - (fm.width( text )/2), pos, text );
}
p.end();
bitBlt( this, 0, 0, offscreen, 0, 0, sWidth, sHeight, Qt::CopyROP, true );
}
void SFCave :: dealWithMenuSelection()
{
switch( currentMenuNr )
{
case MENU_MAIN_MENU:
{
switch( currentMenuOption[currentMenuNr] )
{
case MENU_START_GAME:
state = STATE_NEWGAME;
break;
case MENU_REPLAY:
currentMenuNr = MENU_REPLAY_MENU;
currentMenuOption[currentMenuNr] = 0;
break;
case MENU_OPTIONS:
currentMenuNr = MENU_OPTIONS_MENU;
currentMenuOption[currentMenuNr] = 0;
break;
case MENU_HELP:
{
// Display Help Menu
HelpWindow *dlg = new HelpWindow( this );
dlg->exec();
delete dlg;
break;
}
case MENU_QUIT:
QApplication::exit();
break;
}
break;
}
case MENU_OPTIONS_MENU:
{
switch( currentMenuOption[currentMenuNr] )
{
case MENU_GAME_TYPE:
break;
case MENU_GAME_DIFFICULTY:
break;
case MENU_CLEAR_HIGHSCORES:
for ( int i = 0 ; i < 3 ; ++i )
highestScore[currentGameType][i] = 0;
break;
case MENU_BACK:
currentMenuNr = MENU_MAIN_MENU;
#ifdef QWS
Config cfg( "sfcave" );
cfg.setGroup( "settings" );
cfg.writeEntry( "difficulty", currentGameDifficulty );
cfg.writeEntry( "gameType", currentGameType );
#endif
break;
}
break;
}
case MENU_REPLAY_MENU:
{
switch( currentMenuOption[currentMenuNr] )
{
case MENU_REPLAY_START:
if ( currentSeed != 0 )
state = STATE_REPLAY;
// Display No Replay
break;
case MENU_REPLAY_LOAD:
loadReplay();
break;
case MENU_REPLAY_SAVE:
saveReplay();
break;
case MENU_REPLAY_BACK:
currentMenuNr = MENU_MAIN_MENU;
break;
}
}
}
}
diff --git a/noncore/games/sfcave/sfcave.h b/noncore/games/sfcave/sfcave.h
index f95558d..b1fe819 100644
--- a/noncore/games/sfcave/sfcave.h
+++ b/noncore/games/sfcave/sfcave.h
@@ -1,131 +1,131 @@
#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[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();
void start();
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();
};