author | andyq <andyq> | 2003-01-21 20:37:00 (UTC) |
---|---|---|
committer | andyq <andyq> | 2003-01-21 20:37:00 (UTC) |
commit | 0a6563fcc2f49857c581d9def24407a3a4ef526c (patch) (unidiff) | |
tree | f1b82a4bd7582ef2cb722cffb87eecff1e1f96e6 /noncore/games/sfcave-sdl | |
parent | 50b5915b48fc5cbacf23e4d2b75d7a266f141a4a (diff) | |
download | opie-0a6563fcc2f49857c581d9def24407a3a4ef526c.zip opie-0a6563fcc2f49857c581d9def24407a3a4ef526c.tar.gz opie-0a6563fcc2f49857c581d9def24407a3a4ef526c.tar.bz2 |
Clean up of code - fixed memory leaks (most of them) and added new custom config menu
25 files changed, 682 insertions, 300 deletions
diff --git a/noncore/games/sfcave-sdl/animatedimage.cpp b/noncore/games/sfcave-sdl/animatedimage.cpp index d9d6ff6..441c647 100644 --- a/noncore/games/sfcave-sdl/animatedimage.cpp +++ b/noncore/games/sfcave-sdl/animatedimage.cpp | |||
@@ -1,36 +1,33 @@ | |||
1 | #include "SDL.h" | 1 | #include "SDL.h" |
2 | #include "SDL_image.h" | 2 | #include "SDL_image.h" |
3 | 3 | ||
4 | #include "constants.h" | 4 | #include "constants.h" |
5 | #include "animatedimage.h" | 5 | #include "animatedimage.h" |
6 | 6 | ||
7 | AnimatedImage :: AnimatedImage( QString file, int nFrames ) | 7 | AnimatedImage :: AnimatedImage( string file, int nFrames ) |
8 | { | 8 | { |
9 | nrFrames = nFrames; | 9 | nrFrames = nFrames; |
10 | currentFrame = 0; | 10 | currentFrame = 0; |
11 | 11 | ||
12 | // Load image | 12 | // Load image |
13 | image = IMG_Load( (const char *)file.c_str() ); | 13 | image = IMG_Load( (const char *)file.c_str() ); |
14 | if ( !image ) | 14 | if ( !image ) |
15 | { | 15 | { |
16 | nrFrames = 0; | 16 | nrFrames = 0; |
17 | image = 0; | 17 | image = 0; |
18 | return; | 18 | return; |
19 | } | 19 | } |
20 | 20 | ||
21 | SDL_SetColorKey(image, SDL_SRCCOLORKEY | SDL_RLEACCEL, SDL_MapRGB( image->format, 0, 0, 0 ) ); | 21 | SDL_SetColorKey(image, SDL_SRCCOLORKEY | SDL_RLEACCEL, SDL_MapRGB( image->format, 0, 0, 0 ) ); |
22 | //image = SDL_DisplayFormat( tmp ); | ||
23 | |||
24 | //SDL_FreeSurface( tmp ); | ||
25 | frameWidth = image->w/nrFrames; | 22 | frameWidth = image->w/nrFrames; |
26 | frameHeight = image->h; | 23 | frameHeight = image->h; |
27 | } | 24 | } |
28 | 25 | ||
29 | AnimatedImage :: ~AnimatedImage() | 26 | AnimatedImage :: ~AnimatedImage() |
30 | { | 27 | { |
31 | if ( image != 0 ) | 28 | if ( image != 0 ) |
32 | SDL_FreeSurface( image ); | 29 | SDL_FreeSurface( image ); |
33 | } | 30 | } |
34 | 31 | ||
35 | bool AnimatedImage :: nextFrame() | 32 | bool AnimatedImage :: nextFrame() |
36 | { | 33 | { |
@@ -38,24 +35,27 @@ bool AnimatedImage :: nextFrame() | |||
38 | currentFrame ++; | 35 | currentFrame ++; |
39 | if ( currentFrame >= nrFrames ) | 36 | if ( currentFrame >= nrFrames ) |
40 | { | 37 | { |
41 | currentFrame --; | 38 | currentFrame --; |
42 | rc = false; | 39 | rc = false; |
43 | } | 40 | } |
44 | 41 | ||
45 | return rc; | 42 | return rc; |
46 | } | 43 | } |
47 | 44 | ||
48 | void AnimatedImage :: draw( SDL_Surface *screen, int x, int y ) | 45 | void AnimatedImage :: draw( SDL_Surface *screen, int x, int y ) |
49 | { | 46 | { |
47 | if ( !image ) | ||
48 | return; | ||
49 | |||
50 | SDL_Rect dst; | 50 | SDL_Rect dst; |
51 | dst.x = currentFrame * frameWidth; | 51 | dst.x = currentFrame * frameWidth; |
52 | dst.y = 0; | 52 | dst.y = 0; |
53 | dst.w = frameWidth; | 53 | dst.w = frameWidth; |
54 | dst.h = frameHeight; | 54 | dst.h = frameHeight; |
55 | 55 | ||
56 | SDL_Rect dst2; | 56 | SDL_Rect dst2; |
57 | dst2.x = x - (frameWidth/2); | 57 | dst2.x = x - (frameWidth/2); |
58 | dst2.y = y - (frameHeight/2);; | 58 | dst2.y = y - (frameHeight/2);; |
59 | SDL_BlitSurface( image, &dst, screen, &dst2 ); | 59 | SDL_BlitSurface( image, &dst, screen, &dst2 ); |
60 | } | 60 | } |
61 | 61 | ||
diff --git a/noncore/games/sfcave-sdl/animatedimage.h b/noncore/games/sfcave-sdl/animatedimage.h index 1b38e6d..3c03f52 100644 --- a/noncore/games/sfcave-sdl/animatedimage.h +++ b/noncore/games/sfcave-sdl/animatedimage.h | |||
@@ -1,21 +1,21 @@ | |||
1 | #ifndef __ANIMATED_IMAGE_H | 1 | #ifndef __ANIMATED_IMAGE_H |
2 | #define __ANIMATED_IMAGE_H | 2 | #define __ANIMATED_IMAGE_H |
3 | 3 | ||
4 | #include "SDL.h" | 4 | #include "SDL.h" |
5 | 5 | ||
6 | class AnimatedImage | 6 | class AnimatedImage |
7 | { | 7 | { |
8 | public: | 8 | public: |
9 | AnimatedImage( QString file, int nFrames ); | 9 | AnimatedImage( string file, int nFrames ); |
10 | ~AnimatedImage(); | 10 | ~AnimatedImage(); |
11 | 11 | ||
12 | bool nextFrame(); | 12 | bool nextFrame(); |
13 | void draw( SDL_Surface *screen, int x, int y ); | 13 | void draw( SDL_Surface *screen, int x, int y ); |
14 | bool AtEnd(); | 14 | bool AtEnd(); |
15 | void reset() { currentFrame = 0; } | 15 | void reset() { currentFrame = 0; } |
16 | private: | 16 | private: |
17 | 17 | ||
18 | SDL_Surface *image; | 18 | SDL_Surface *image; |
19 | int nrFrames; | 19 | int nrFrames; |
20 | int currentFrame; | 20 | int currentFrame; |
21 | 21 | ||
diff --git a/noncore/games/sfcave-sdl/bfont.cpp b/noncore/games/sfcave-sdl/bfont.cpp index 0f29104..7dec8f5 100644 --- a/noncore/games/sfcave-sdl/bfont.cpp +++ b/noncore/games/sfcave-sdl/bfont.cpp | |||
@@ -64,28 +64,24 @@ void BFont::LoadFont (const char *filename) | |||
64 | { | 64 | { |
65 | Surface = surface; | 65 | Surface = surface; |
66 | for (x=0; x<256; x++) | 66 | for (x=0; x<256; x++) |
67 | { | 67 | { |
68 | Chars[x].x = 0; | 68 | Chars[x].x = 0; |
69 | Chars[x].y = 0; | 69 | Chars[x].y = 0; |
70 | Chars[x].h = 0; | 70 | Chars[x].h = 0; |
71 | Chars[x].w = 0; | 71 | Chars[x].w = 0; |
72 | } | 72 | } |
73 | InitFont(); // Init the font | 73 | InitFont(); // Init the font |
74 | } | 74 | } |
75 | } | 75 | } |
76 | else | ||
77 | { | ||
78 | cerr << "Error! The font has not been loaded!" << endl; | ||
79 | } | ||
80 | } | 76 | } |
81 | 77 | ||
82 | BFont * BFont :: SetFontColor(Uint8 r, Uint8 g, Uint8 b) | 78 | BFont * BFont :: SetFontColor(Uint8 r, Uint8 g, Uint8 b) |
83 | { | 79 | { |
84 | int x,y; | 80 | int x,y; |
85 | 81 | ||
86 | BFont *newfont; | 82 | BFont *newfont; |
87 | SDL_Surface *surface = NULL; | 83 | SDL_Surface *surface = NULL; |
88 | 84 | ||
89 | Uint32 pixel; | 85 | Uint32 pixel; |
90 | Uint8 old_r, old_g, old_b; | 86 | Uint8 old_r, old_g, old_b; |
91 | Uint8 new_r, new_g, new_b; | 87 | Uint8 new_r, new_g, new_b; |
@@ -104,43 +100,42 @@ BFont * BFont :: SetFontColor(Uint8 r, Uint8 g, Uint8 b) | |||
104 | newfont->Chars[x].w = Chars[x].w; | 100 | newfont->Chars[x].w = Chars[x].w; |
105 | } | 101 | } |
106 | 102 | ||
107 | surface = SDL_CreateRGBSurface(SDL_SWSURFACE, Surface->w, Surface->h, 32, | 103 | surface = SDL_CreateRGBSurface(SDL_SWSURFACE, Surface->w, Surface->h, 32, |
108 | 0x000000ff,0x0000ff00, 0x00ff0000, 0xff000000); | 104 | 0x000000ff,0x0000ff00, 0x00ff0000, 0xff000000); |
109 | if (surface != NULL) { | 105 | if (surface != NULL) { |
110 | 106 | ||
111 | if (SDL_MUSTLOCK(surface)) SDL_LockSurface(surface); | 107 | if (SDL_MUSTLOCK(surface)) SDL_LockSurface(surface); |
112 | if (SDL_MUSTLOCK(Surface)) SDL_LockSurface(Surface); | 108 | if (SDL_MUSTLOCK(Surface)) SDL_LockSurface(Surface); |
113 | 109 | ||
114 | color_key = xGetPixel(Surface, 0, Surface->h-1); | 110 | color_key = xGetPixel(Surface, 0, Surface->h-1); |
115 | 111 | ||
116 | printf("looking...\n"); | ||
117 | for( x=0; x < Surface->w; x++) { | 112 | for( x=0; x < Surface->w; x++) { |
118 | for( y=0; y < Surface->h; y++) { | 113 | for( y=0; y < Surface->h; y++) { |
119 | old_r = old_g = old_b = 0; | 114 | old_r = old_g = old_b = 0; |
120 | pixel = xGetPixel(Surface,x,y); | 115 | pixel = xGetPixel(Surface,x,y); |
121 | 116 | ||
122 | if (pixel != color_key) { | 117 | if (pixel != color_key) { |
123 | SDL_GetRGB(pixel, Surface->format, &old_r,&old_g,&old_b); | 118 | SDL_GetRGB(pixel, Surface->format, &old_r,&old_g,&old_b); |
124 | 119 | ||
125 | new_r = (Uint8) ((old_r * r) / 255); | 120 | new_r = (Uint8) ((old_r * r) / 255); |
126 | new_g = (Uint8) ((old_g * g) / 255); | 121 | new_g = (Uint8) ((old_g * g) / 255); |
127 | new_b = (Uint8) ((old_b * b) / 255); | 122 | new_b = (Uint8) ((old_b * b) / 255); |
128 | 123 | ||
129 | pixel = SDL_MapRGB(surface->format,new_r,new_g,new_b); | 124 | pixel = SDL_MapRGB(surface->format,new_r,new_g,new_b); |
130 | } | 125 | } |
131 | PutPixel(surface,x,y,pixel); | 126 | PutPixel(surface,x,y,pixel); |
132 | } | 127 | } |
133 | } | 128 | } |
134 | printf("unlooking...\n"); | 129 | |
135 | if (SDL_MUSTLOCK(surface)) SDL_UnlockSurface(surface); | 130 | if (SDL_MUSTLOCK(surface)) SDL_UnlockSurface(surface); |
136 | if (SDL_MUSTLOCK(Surface)) SDL_UnlockSurface(Surface); | 131 | if (SDL_MUSTLOCK(Surface)) SDL_UnlockSurface(Surface); |
137 | 132 | ||
138 | SDL_SetColorKey(surface, SDL_SRCCOLORKEY, color_key); | 133 | SDL_SetColorKey(surface, SDL_SRCCOLORKEY, color_key); |
139 | } | 134 | } |
140 | 135 | ||
141 | newfont->Surface = surface; | 136 | newfont->Surface = surface; |
142 | } | 137 | } |
143 | return newfont; | 138 | return newfont; |
144 | } | 139 | } |
145 | 140 | ||
146 | 141 | ||
diff --git a/noncore/games/sfcave-sdl/constants.h b/noncore/games/sfcave-sdl/constants.h index 8fadae4..f10764e 100644 --- a/noncore/games/sfcave-sdl/constants.h +++ b/noncore/games/sfcave-sdl/constants.h | |||
@@ -1,18 +1,17 @@ | |||
1 | #ifndef __CONSTANTS_H | 1 | #ifndef __CONSTANTS_H |
2 | #define __CONSTANTS_H | 2 | #define __CONSTANTS_H |
3 | 3 | ||
4 | #include <string> | 4 | #include <string> |
5 | using namespace std; | 5 | using namespace std; |
6 | #define QString string | ||
7 | 6 | ||
8 | #ifdef QWS | 7 | #ifdef QWS |
9 | #define IMAGES_PATH "/opt/QtPalmtop/pics/sfcave/data/" | 8 | #define IMAGES_PATH "/opt/QtPalmtop/pics/sfcave/data/" |
10 | #define SOUND_PATH "/opt/QtPalmtop/sounds/sfcave/" | 9 | #define SOUND_PATH "/opt/QtPalmtop/sounds/sfcave/" |
11 | #else | 10 | #else |
12 | #define IMAGES_PATH "./images/" | 11 | #define IMAGES_PATH "./images/" |
13 | #define SOUND_PATH "./sounds/" | 12 | #define SOUND_PATH "./sounds/" |
14 | #endif | 13 | #endif |
15 | 14 | ||
16 | // Width and height of app | 15 | // Width and height of app |
17 | #define WIDTH240 | 16 | #define WIDTH240 |
18 | #define HEIGHT320 | 17 | #define HEIGHT320 |
@@ -46,22 +45,40 @@ using namespace std; | |||
46 | #define MENU_LOAD_REPLAY 7 | 45 | #define MENU_LOAD_REPLAY 7 |
47 | #define MENU_SAVE_REPLAY 8 | 46 | #define MENU_SAVE_REPLAY 8 |
48 | #define MENU_BACK 9 | 47 | #define MENU_BACK 9 |
49 | #define MENU_GAME_TYPE 10 | 48 | #define MENU_GAME_TYPE 10 |
50 | #define MENU_DIFFICULTY 11 | 49 | #define MENU_DIFFICULTY 11 |
51 | #define MENU_CLEAR_SCORES 12 | 50 | #define MENU_CLEAR_SCORES 12 |
52 | #define MENU_GAME_SFCAVE13 | 51 | #define MENU_GAME_SFCAVE13 |
53 | #define MENU_GAME_GATES 14 | 52 | #define MENU_GAME_GATES 14 |
54 | #define MENU_GAME_FLY 15 | 53 | #define MENU_GAME_FLY 15 |
55 | #define MENU_DIFFICULTY_EASY16 | 54 | #define MENU_DIFFICULTY_EASY16 |
56 | #define MENU_DIFFICULTY_NORMAL17 | 55 | #define MENU_DIFFICULTY_NORMAL17 |
57 | #define MENU_DIFFICULTY_HARD18 | 56 | #define MENU_DIFFICULTY_HARD18 |
58 | #define MENU_SOUNDS 19 | 57 | #define MENU_DIFFICULTY_HARD18 |
59 | #define MENU_SOUND_ON 20 | 58 | #define MENU_DIFFICULTY_CUSTOM19 |
60 | #define MENU_SOUND_OFF 21 | 59 | #define MENU_SOUNDS 20 |
61 | #define MENU_MUSIC_ON 22 | 60 | #define MENU_SOUND_ON 21 |
62 | #define MENU_MUSIC_OFF 23 | 61 | #define MENU_SOUND_OFF 22 |
62 | #define MENU_MUSIC_ON 23 | ||
63 | #define MENU_MUSIC_OFF 24 | ||
64 | #define MENU_CUSTOM_THRUST 25 | ||
65 | #define MENU_CUSTOM_GRAVITY 26 | ||
66 | #define MENU_CUSTOM_MAXSPEEDUP 27 | ||
67 | #define MENU_CUSTOM_MAXSPEEDDOWN 28 | ||
68 | #define MENU_CUSTOM_INCREASE 29 | ||
69 | #define MENU_CUSTOM_DECREASE 30 | ||
70 | #define MENU_CUSTOM_SAVE 31 | ||
71 | #define MENU_CUSTOM_CANCEL 32 | ||
63 | 72 | ||
64 | // Sounds | 73 | // Sounds |
65 | #define SND_EXPLOSION 0 | 74 | #define SND_EXPLOSION 0 |
66 | #define SND_THRUST 1 | 75 | #define SND_THRUST 1 |
76 | #define INGAME_MUSIC SOUND_PATH "ingame.mod" | ||
77 | |||
78 | // Constants for player values | ||
79 | #define PLAYER_THRUST 0 | ||
80 | #define PLAYER_GRAVITY 1 | ||
81 | #define PLAYER_MAX_SPEED_UP 2 | ||
82 | #define PLAYER_MAX_SPEED_DOWN 3 | ||
83 | |||
67 | #endif | 84 | #endif |
diff --git a/noncore/games/sfcave-sdl/fly_game.cpp b/noncore/games/sfcave-sdl/fly_game.cpp index f5ab401..7605c3f 100644 --- a/noncore/games/sfcave-sdl/fly_game.cpp +++ b/noncore/games/sfcave-sdl/fly_game.cpp | |||
@@ -8,77 +8,86 @@ FlyGame :: FlyGame( SFCave *p, int w, int h, int diff ) | |||
8 | : Game( p, w, h, diff ) | 8 | : Game( p, w, h, diff ) |
9 | { | 9 | { |
10 | gameName = "Fly"; | 10 | gameName = "Fly"; |
11 | difficulty = MENU_DIFFICULTY_EASY; | 11 | difficulty = MENU_DIFFICULTY_EASY; |
12 | 12 | ||
13 | terrain = new FlyTerrain( w, h ); | 13 | terrain = new FlyTerrain( w, h ); |
14 | player = new Player( w, h ); | 14 | player = new Player( w, h ); |
15 | highScore = 0; | 15 | highScore = 0; |
16 | } | 16 | } |
17 | 17 | ||
18 | FlyGame :: ~FlyGame() | 18 | FlyGame :: ~FlyGame() |
19 | { | 19 | { |
20 | // terrain and player get deleted by parent class | ||
20 | } | 21 | } |
21 | 22 | ||
22 | void FlyGame :: init() | 23 | void FlyGame :: init() |
23 | { | 24 | { |
24 | Game :: init(); | 25 | Game :: init(); |
25 | 26 | ||
26 | switch( difficulty ) | 27 | switch( difficulty ) |
27 | { | 28 | { |
28 | case MENU_DIFFICULTY_EASY: | 29 | case MENU_DIFFICULTY_EASY: |
29 | player->setMovementInfo( 0.3, 0.2, 1.5, 1.5 ); | 30 | player->setMovementInfo( 0.3, 0.2, 1.5, 1.5 ); |
30 | break; | 31 | break; |
31 | case MENU_DIFFICULTY_NORMAL: | 32 | case MENU_DIFFICULTY_NORMAL: |
32 | player->setMovementInfo( 0.35, 0.4, 2.5, 3 ); | 33 | player->setMovementInfo( 0.35, 0.4, 2.5, 3 ); |
33 | break; | 34 | break; |
34 | case MENU_DIFFICULTY_HARD: | 35 | case MENU_DIFFICULTY_HARD: |
35 | player->setMovementInfo( 0.4, 0.6, 4, 5 ); | 36 | player->setMovementInfo( 0.4, 0.6, 4, 5 ); |
36 | break; | 37 | break; |
38 | case MENU_DIFFICULTY_CUSTOM: | ||
39 | { | ||
40 | double thrust = parent->loadDoubleSetting( "Fly_custom_player_thrust", 0.3 ); | ||
41 | double gravity = parent->loadDoubleSetting( "Fly_custom_player_gravity", 0.2 ); | ||
42 | double maxUp = parent->loadDoubleSetting( "Fly_custom_player_maxupspeed", 1.5 ); | ||
43 | double maxDown = parent->loadDoubleSetting( "Fly_custom_player_maxdownspeed", 1.5 ); | ||
44 | player->setMovementInfo( thrust, gravity, maxUp, maxDown ); | ||
45 | break; | ||
46 | } | ||
37 | } | 47 | } |
38 | 48 | ||
39 | startScoring = false; | 49 | startScoring = false; |
40 | } | 50 | } |
41 | 51 | ||
42 | void FlyGame :: update( int state ) | 52 | void FlyGame :: update( int state ) |
43 | { | 53 | { |
44 | Game::update( state ); | 54 | Game::update( state ); |
45 | 55 | ||
46 | if ( state == STATE_PLAYING ) | 56 | if ( state == STATE_PLAYING ) |
47 | { | 57 | { |
48 | 58 | ||
49 | if ( nrFrames % 3 == 0 ) | 59 | if ( nrFrames % 3 == 0 ) |
50 | { | 60 | { |
51 | int diff = terrain->getMapBottom( 10 ) - player->getY(); | 61 | int diff = terrain->getMapBottom( 10 ) - player->getY(); |
52 | int tmpScore = ((FlyTerrain *)terrain)->getScore( 1, diff ); | 62 | int tmpScore = ((FlyTerrain *)terrain)->getScore( 1, diff ); |
53 | // printf( "diff - %d score - %d\n", diff, tmpScore ); | 63 | |
54 | if ( !startScoring ) | 64 | if ( !startScoring ) |
55 | { | 65 | { |
56 | if ( tmpScore > 0 ) | 66 | if ( tmpScore > 0 ) |
57 | startScoring = true; | 67 | startScoring = true; |
58 | } | 68 | } |
59 | 69 | ||
60 | if ( startScoring ) | 70 | if ( startScoring ) |
61 | { | 71 | { |
62 | // Update score | 72 | // Update score |
63 | // get distance between landscape and ship | 73 | // get distance between landscape and ship |
64 | 74 | ||
65 | // the closer the difference is to 0 means more points | 75 | // the closer the difference is to 0 means more points |
66 | score += tmpScore; | 76 | score += tmpScore; |
67 | } | 77 | } |
68 | } | 78 | } |
69 | 79 | ||
70 | if ( checkCollisions() ) | 80 | if ( checkCollisions() ) |
71 | { | 81 | { |
72 | // printf( "Crashed!\n" ); | ||
73 | parent->changeState( STATE_CRASHING ); | 82 | parent->changeState( STATE_CRASHING ); |
74 | return; | 83 | return; |
75 | } | 84 | } |
76 | 85 | ||
77 | // Game logic goes here | 86 | // Game logic goes here |
78 | terrain->moveTerrain( 5 ); | 87 | terrain->moveTerrain( 5 ); |
79 | player->move( press ); | 88 | player->move( press ); |
80 | } | 89 | } |
81 | } | 90 | } |
82 | 91 | ||
83 | void FlyGame :: draw( SDL_Surface *screen ) | 92 | void FlyGame :: draw( SDL_Surface *screen ) |
84 | { | 93 | { |
diff --git a/noncore/games/sfcave-sdl/font.cpp b/noncore/games/sfcave-sdl/font.cpp index 2976d48..1988252 100644 --- a/noncore/games/sfcave-sdl/font.cpp +++ b/noncore/games/sfcave-sdl/font.cpp | |||
@@ -1,40 +1,52 @@ | |||
1 | #include "font.h" | 1 | #include "font.h" |
2 | 2 | ||
3 | #include "constants.h" | 3 | #include "constants.h" |
4 | 4 | ||
5 | BFont *FontHandler :: menuSelFont; | 5 | BFont *FontHandler :: menuSelFont; |
6 | BFont *FontHandler :: menuUnSelFont; | 6 | BFont *FontHandler :: menuUnSelFont; |
7 | BFont *FontHandler :: whiteFont; | 7 | BFont *FontHandler :: whiteFont; |
8 | BFont *FontHandler :: colouredFont; | 8 | BFont *FontHandler :: colouredFont; |
9 | BFont *FontHandler :: helpFont; | 9 | BFont *FontHandler :: helpFont; |
10 | 10 | ||
11 | void FontHandler :: init() | 11 | bool FontHandler :: init() |
12 | { | 12 | { |
13 | // Load font images | 13 | // Load font images |
14 | // Convert to fonts | 14 | // Convert to fonts |
15 | menuSelFont = new BFont( IMAGES_PATH "sel_menu_font.bmp" ); | 15 | menuSelFont = new BFont( IMAGES_PATH "sel_menu_font.bmp" ); |
16 | menuUnSelFont = new BFont( IMAGES_PATH "unsel_menu_font.bmp" ); | 16 | menuUnSelFont = new BFont( IMAGES_PATH "unsel_menu_font.bmp" ); |
17 | whiteFont = new BFont( IMAGES_PATH "score_font.bmp" ); | 17 | whiteFont = new BFont( IMAGES_PATH "score_font.bmp" ); |
18 | helpFont = new BFont( IMAGES_PATH "help_font.bmp" ); | 18 | helpFont = new BFont( IMAGES_PATH "help_font.bmp" ); |
19 | colouredFont = 0; | 19 | colouredFont = 0; |
20 | |||
21 | // Check if we are installed correctly (we need fonts to function) | ||
22 | if ( menuSelFont == 0 || menuUnSelFont == 0 || whiteFont == 0 || helpFont == 0 ) | ||
23 | { | ||
24 | printf( "One or more fonts are not installed correctly\n" ); | ||
25 | return false; | ||
26 | } | ||
27 | |||
28 | return true; | ||
20 | } | 29 | } |
21 | 30 | ||
22 | void FontHandler :: cleanUp() | 31 | void FontHandler :: cleanUp() |
23 | { | 32 | { |
33 | if ( menuSelFont ) | ||
24 | delete menuSelFont; | 34 | delete menuSelFont; |
35 | if ( menuUnSelFont ) | ||
25 | delete menuUnSelFont; | 36 | delete menuUnSelFont; |
37 | if ( whiteFont ) | ||
26 | delete whiteFont; | 38 | delete whiteFont; |
39 | if ( helpFont ) | ||
27 | delete helpFont; | 40 | delete helpFont; |
28 | |||
29 | if ( colouredFont ) | 41 | if ( colouredFont ) |
30 | delete colouredFont; | 42 | delete colouredFont; |
31 | } | 43 | } |
32 | 44 | ||
33 | int FontHandler :: TextWidth( int font, const char *text ) | 45 | int FontHandler :: TextWidth( int font, const char *text ) |
34 | { | 46 | { |
35 | return getFont( font )->TextWidth( text ); | 47 | return getFont( font )->TextWidth( text ); |
36 | } | 48 | } |
37 | 49 | ||
38 | int FontHandler :: FontHeight( int font ) | 50 | int FontHandler :: FontHeight( int font ) |
39 | { | 51 | { |
40 | return getFont( font )->FontHeight(); | 52 | return getFont( font )->FontHeight(); |
diff --git a/noncore/games/sfcave-sdl/font.h b/noncore/games/sfcave-sdl/font.h index e5bb707..5f0674a 100644 --- a/noncore/games/sfcave-sdl/font.h +++ b/noncore/games/sfcave-sdl/font.h | |||
@@ -4,25 +4,25 @@ | |||
4 | #include "SDL.h" | 4 | #include "SDL.h" |
5 | #include "bfont.h" | 5 | #include "bfont.h" |
6 | 6 | ||
7 | #define FONT_MENU_HIGHLIGHTED 1 | 7 | #define FONT_MENU_HIGHLIGHTED 1 |
8 | #define FONT_MENU_UNHIGHLIGHTED 2 | 8 | #define FONT_MENU_UNHIGHLIGHTED 2 |
9 | #define FONT_WHITE_TEXT 3 | 9 | #define FONT_WHITE_TEXT 3 |
10 | #define FONT_COLOURED_TEXT 4 | 10 | #define FONT_COLOURED_TEXT 4 |
11 | #define FONT_HELP_FONT 5 | 11 | #define FONT_HELP_FONT 5 |
12 | 12 | ||
13 | class FontHandler | 13 | class FontHandler |
14 | { | 14 | { |
15 | public: | 15 | public: |
16 | static void init(); | 16 | static bool init(); |
17 | static void cleanUp(); | 17 | static void cleanUp(); |
18 | 18 | ||
19 | static int TextWidth( int font, const char *text ); | 19 | static int TextWidth( int font, const char *text ); |
20 | static int FontHeight( int font ); | 20 | static int FontHeight( int font ); |
21 | static void draw( SDL_Surface *screen, int font, const char *text, int x, int y ); | 21 | static void draw( SDL_Surface *screen, int font, const char *text, int x, int y ); |
22 | static void changeColor( int font, int r, int g, int b ); | 22 | static void changeColor( int font, int r, int g, int b ); |
23 | 23 | ||
24 | static BFont *getFont( int font ); | 24 | static BFont *getFont( int font ); |
25 | private: | 25 | private: |
26 | static BFont *menuSelFont; | 26 | static BFont *menuSelFont; |
27 | static BFont *menuUnSelFont; | 27 | static BFont *menuUnSelFont; |
28 | static BFont *whiteFont; | 28 | static BFont *whiteFont; |
diff --git a/noncore/games/sfcave-sdl/game.cpp b/noncore/games/sfcave-sdl/game.cpp index a644696..e41e510 100644 --- a/noncore/games/sfcave-sdl/game.cpp +++ b/noncore/games/sfcave-sdl/game.cpp | |||
@@ -67,67 +67,71 @@ void Game :: init() | |||
67 | player->init(); | 67 | player->init(); |
68 | } | 68 | } |
69 | 69 | ||
70 | void Game :: handleKeys( SDL_KeyboardEvent &key ) | 70 | void Game :: handleKeys( SDL_KeyboardEvent &key ) |
71 | { | 71 | { |
72 | if ( !replay && key.keysym.sym == SDLK_SPACE ) | 72 | if ( !replay && key.keysym.sym == SDLK_SPACE ) |
73 | { | 73 | { |
74 | if ( key.type == SDL_KEYDOWN ) | 74 | if ( key.type == SDL_KEYDOWN ) |
75 | { | 75 | { |
76 | if ( !press ) | 76 | if ( !press ) |
77 | replayList.push_back( nrFrames ); | 77 | replayList.push_back( nrFrames ); |
78 | press = true; | 78 | press = true; |
79 | |||
80 | // if ( thrustChannel == -1 && parent->getState() == STATE_PLAYING ) | ||
81 | // thrustChannel = SoundHandler :: playSound( SND_THRUST, -1, -1, false ); | ||
82 | } | 79 | } |
83 | else | 80 | else |
84 | { | 81 | { |
85 | if ( press ) | 82 | if ( press ) |
86 | replayList.push_back( nrFrames ); | 83 | replayList.push_back( nrFrames ); |
87 | press = false; | 84 | press = false; |
88 | 85 | ||
89 | if ( thrustChannel != -1 ) | ||
90 | { | ||
91 | // SoundHandler :: stopSound( thrustChannel, true, 300 ); | ||
92 | // thrustChannel = -1; | ||
93 | } | ||
94 | } | 86 | } |
95 | } | 87 | } |
96 | } | 88 | } |
97 | 89 | ||
98 | 90 | ||
99 | 91 | ||
100 | QString Game :: getGameDifficultyText() | 92 | string Game :: getGameDifficultyText() |
101 | { | 93 | { |
102 | QString ret; | 94 | string ret; |
103 | 95 | ||
104 | if ( difficulty == MENU_DIFFICULTY_EASY ) | 96 | if ( difficulty == MENU_DIFFICULTY_EASY ) |
105 | ret = "Easy"; | 97 | ret = "Easy"; |
106 | else if ( difficulty == MENU_DIFFICULTY_NORMAL ) | 98 | else if ( difficulty == MENU_DIFFICULTY_NORMAL ) |
107 | ret = "Medium"; | 99 | ret = "Medium"; |
108 | else if ( difficulty == MENU_DIFFICULTY_HARD ) | 100 | else if ( difficulty == MENU_DIFFICULTY_HARD ) |
109 | ret = "Hard"; | 101 | ret = "Hard"; |
102 | else if ( difficulty == MENU_DIFFICULTY_CUSTOM ) | ||
103 | ret = "Custom"; | ||
110 | 104 | ||
111 | return ret; | 105 | return ret; |
112 | } | 106 | } |
113 | 107 | ||
114 | void Game :: setDifficulty( string diff ) | 108 | void Game :: setDifficulty( string diff ) |
115 | { | 109 | { |
116 | if ( diff == "Easy" ) | 110 | if ( diff == "Easy" ) |
117 | difficulty = MENU_DIFFICULTY_EASY; | 111 | difficulty = MENU_DIFFICULTY_EASY; |
118 | else if ( diff == "Medium" ) | 112 | else if ( diff == "Medium" ) |
119 | difficulty = MENU_DIFFICULTY_NORMAL; | 113 | difficulty = MENU_DIFFICULTY_NORMAL; |
120 | else if ( diff == "Hard" ) | 114 | else if ( diff == "Hard" ) |
121 | difficulty = MENU_DIFFICULTY_HARD; | 115 | difficulty = MENU_DIFFICULTY_HARD; |
116 | else if ( diff == "Custom" ) | ||
117 | difficulty = MENU_DIFFICULTY_CUSTOM; | ||
118 | |||
119 | init(); | ||
120 | } | ||
121 | |||
122 | void Game :: setDifficulty( int diff ) | ||
123 | { | ||
124 | difficulty = diff; | ||
125 | init(); | ||
122 | } | 126 | } |
123 | 127 | ||
124 | void Game :: update( int state ) | 128 | void Game :: update( int state ) |
125 | { | 129 | { |
126 | nrFrames ++; | 130 | nrFrames ++; |
127 | 131 | ||
128 | if ( score > highScore ) | 132 | if ( score > highScore ) |
129 | highScore = score; | 133 | highScore = score; |
130 | 134 | ||
131 | 135 | ||
132 | if ( state == STATE_PLAYING ) | 136 | if ( state == STATE_PLAYING ) |
133 | { | 137 | { |
@@ -157,32 +161,31 @@ void Game :: update( int state ) | |||
157 | parent->changeState( STATE_CRASHED ); | 161 | parent->changeState( STATE_CRASHED ); |
158 | 162 | ||
159 | } | 163 | } |
160 | } | 164 | } |
161 | 165 | ||
162 | void Game :: preDraw( SDL_Surface *screen ) | 166 | void Game :: preDraw( SDL_Surface *screen ) |
163 | { | 167 | { |
164 | } | 168 | } |
165 | 169 | ||
166 | void Game :: draw( SDL_Surface *screen ) | 170 | void Game :: draw( SDL_Surface *screen ) |
167 | { | 171 | { |
168 | char tmp[100]; | 172 | char tmp[100]; |
169 | QString scoreText; | 173 | string scoreText; |
170 | sprintf( tmp, "Score: %06ld High Score: %06ld", score, highScore ); | 174 | sprintf( tmp, "Score: %06ld High Score: %06ld", score, highScore ); |
171 | //printf( "%s\n", (const char *)scoreText ); | ||
172 | FontHandler::draw( screen, FONT_WHITE_TEXT, tmp, 3, 10 ); | 175 | FontHandler::draw( screen, FONT_WHITE_TEXT, tmp, 3, 10 ); |
173 | 176 | ||
174 | if ( parent->getState() == STATE_CRASHED ) | 177 | if ( parent->getState() == STATE_CRASHED ) |
175 | { | 178 | { |
176 | QString crashText; | 179 | string crashText; |
177 | crashText = "Game Over"; | 180 | crashText = "Game Over"; |
178 | int x = (240 - FontHandler::TextWidth( FONT_WHITE_TEXT, (const char *)crashText.c_str() )) / 2; | 181 | int x = (240 - FontHandler::TextWidth( FONT_WHITE_TEXT, (const char *)crashText.c_str() )) / 2; |
179 | FontHandler::draw( screen, FONT_WHITE_TEXT, (const char *)crashText.c_str(), x, 150 ); | 182 | FontHandler::draw( screen, FONT_WHITE_TEXT, (const char *)crashText.c_str(), x, 150 ); |
180 | 183 | ||
181 | int fontHeight = FontHandler::FontHeight( FONT_WHITE_TEXT ); | 184 | int fontHeight = FontHandler::FontHeight( FONT_WHITE_TEXT ); |
182 | crashText = "Press Middle Button to play again"; | 185 | crashText = "Press Middle Button to play again"; |
183 | x = (240 - FontHandler::TextWidth( FONT_WHITE_TEXT, (const char *)crashText.c_str() )) / 2; | 186 | x = (240 - FontHandler::TextWidth( FONT_WHITE_TEXT, (const char *)crashText.c_str() )) / 2; |
184 | FontHandler::draw( screen, FONT_WHITE_TEXT, (const char *)crashText.c_str(), x, 150 + fontHeight ); | 187 | FontHandler::draw( screen, FONT_WHITE_TEXT, (const char *)crashText.c_str(), x, 150 + fontHeight ); |
185 | 188 | ||
186 | crashText = "or OK for menu"; | 189 | crashText = "or OK for menu"; |
187 | x = (240 - FontHandler::TextWidth( FONT_WHITE_TEXT, (const char *)crashText.c_str() )) / 2; | 190 | x = (240 - FontHandler::TextWidth( FONT_WHITE_TEXT, (const char *)crashText.c_str() )) / 2; |
188 | FontHandler::draw( screen, FONT_WHITE_TEXT, (const char *)crashText.c_str(), x, 150 + 2*fontHeight ); | 191 | FontHandler::draw( screen, FONT_WHITE_TEXT, (const char *)crashText.c_str(), x, 150 + 2*fontHeight ); |
@@ -214,112 +217,105 @@ void Game :: stateChanged( int from, int to ) | |||
214 | } | 217 | } |
215 | } | 218 | } |
216 | 219 | ||
217 | void Game :: setSeed( int seed ) | 220 | void Game :: setSeed( int seed ) |
218 | { | 221 | { |
219 | if ( seed == -1 ) | 222 | if ( seed == -1 ) |
220 | currentSeed = ((unsigned long) time((time_t *) NULL)); | 223 | currentSeed = ((unsigned long) time((time_t *) NULL)); |
221 | else | 224 | else |
222 | currentSeed = seed; | 225 | currentSeed = seed; |
223 | PutSeed( currentSeed ); | 226 | PutSeed( currentSeed ); |
224 | } | 227 | } |
225 | 228 | ||
226 | void Game :: saveReplay( QString file ) | 229 | void Game :: saveReplay( string file ) |
227 | { | 230 | { |
228 | FILE *out; | 231 | FILE *out; |
229 | out = fopen( file.c_str(), "w" ); | 232 | out = fopen( file.c_str(), "w" ); |
230 | if ( !out ) | 233 | if ( !out ) |
231 | { | 234 | { |
232 | printf( "Couldn't write to /home/root/%s\n", file.c_str() ); | 235 | printf( "Couldn't write to /home/root/%s\n", file.c_str() ); |
233 | parent->setMenuStatusText( "Couldn't save replay file" ); | 236 | parent->setMenuStatusText( "Couldn't save replay file" ); |
234 | return; | 237 | return; |
235 | } | 238 | } |
236 | 239 | ||
237 | // Build up string of values | 240 | // Build up string of values |
238 | // Format is:: <landscape seed> <game type> <difficulty> <framenr> <framenr>....... | 241 | // Format is:: <landscape seed> <game type> <difficulty> <framenr> <framenr>....... |
239 | QString val; | 242 | string val; |
240 | char tmp[20]; | 243 | char tmp[20]; |
241 | sprintf( tmp, "%d %d ", currentSeed, difficulty ); | 244 | sprintf( tmp, "%d %d ", currentSeed, difficulty ); |
242 | val = tmp; | 245 | val = tmp; |
243 | 246 | ||
244 | list<int>::iterator it = replayList.begin(); | 247 | list<int>::iterator it = replayList.begin(); |
245 | while( it != replayList.end() ) | 248 | while( it != replayList.end() ) |
246 | { | 249 | { |
247 | sprintf( tmp, "%d ", *it ); | 250 | sprintf( tmp, "%d ", *it ); |
248 | val += tmp; | 251 | val += tmp; |
249 | 252 | ||
250 | it++; | 253 | it++; |
251 | } | 254 | } |
252 | val += "\n"; | 255 | val += "\n"; |
253 | 256 | ||
254 | QString line; | 257 | string line; |
255 | sprintf( tmp, "%d\n", val.length() ); | 258 | sprintf( tmp, "%d\n", val.length() ); |
256 | line = tmp; | 259 | line = tmp; |
257 | fwrite( line.c_str(), 1, line.length(), out ); | 260 | fwrite( line.c_str(), 1, line.length(), out ); |
258 | 261 | ||
259 | fwrite( val.c_str(), 1, val.length(), out ); | 262 | fwrite( val.c_str(), 1, val.length(), out ); |
260 | 263 | ||
261 | fclose( out ); | 264 | fclose( out ); |
262 | |||
263 | printf( "Replay saved to %s\n", (const char *)file.c_str() ); | ||
264 | |||
265 | } | 265 | } |
266 | 266 | ||
267 | void Game :: loadReplay( QString file ) | 267 | void Game :: loadReplay( string file ) |
268 | { | 268 | { |
269 | 269 | ||
270 | FILE *in = fopen( (const char *)file.c_str(), "r" ); | 270 | FILE *in = fopen( (const char *)file.c_str(), "r" ); |
271 | 271 | ||
272 | if ( in == 0 ) | 272 | if ( in == 0 ) |
273 | { | 273 | { |
274 | printf( "Couldn't load replay file %s!\n", (const char *)file.c_str() ); | 274 | printf( "Couldn't load replay file %s!\n", (const char *)file.c_str() ); |
275 | parent->setMenuStatusText( "Couldn't load replay file" ); | 275 | parent->setMenuStatusText( "Couldn't load replay file" ); |
276 | return; | 276 | return; |
277 | } | 277 | } |
278 | 278 | ||
279 | // Read next line - contains the size of the options | 279 | // Read next line - contains the size of the options |
280 | char line[10+1]; | 280 | char line[10+1]; |
281 | fgets( line, 10, in ); | 281 | fgets( line, 10, in ); |
282 | 282 | ||
283 | int length = -1; | 283 | int length = -1; |
284 | sscanf( line, "%d", &length ); | 284 | sscanf( line, "%d", &length ); |
285 | char *data = new char[length+1]; | 285 | char *data = new char[length+1]; |
286 | 286 | ||
287 | fread( data, 1, length, in ); | 287 | fread( data, 1, length, in ); |
288 | // printf( "data - %s", data ); | ||
289 | 288 | ||
290 | QString sep = " "; | 289 | string sep = " "; |
291 | 290 | ||
292 | StringTokenizer st( data, sep ); | 291 | StringTokenizer st( data, sep ); |
293 | 292 | ||
294 | // print it out | 293 | // print it out |
295 | vector<string>::iterator it = st.begin(); | 294 | vector<string>::iterator it = st.begin(); |
296 | currentSeed = atoi( (*it).c_str() ); | 295 | currentSeed = atoi( (*it).c_str() ); |
297 | ++it; | 296 | ++it; |
298 | difficulty = atoi( (*it).c_str() ); | 297 | difficulty = atoi( (*it).c_str() ); |
299 | ++it; | 298 | ++it; |
300 | 299 | ||
301 | replayList.clear(); | 300 | replayList.clear(); |
302 | for ( ; it != st.end(); ++it ) | 301 | for ( ; it != st.end(); ++it ) |
303 | { | 302 | { |
304 | int v = atoi( (*it).c_str() ); | 303 | int v = atoi( (*it).c_str() ); |
305 | replayList.push_back( v ); | 304 | replayList.push_back( v ); |
306 | } | 305 | } |
307 | 306 | ||
308 | delete data; | 307 | delete data; |
309 | 308 | ||
310 | fclose( in ); | 309 | fclose( in ); |
311 | |||
312 | printf( "Replay loaded from %s\n", (const char *)file.c_str() ); | ||
313 | |||
314 | } | 310 | } |
315 | 311 | ||
316 | 312 | ||
317 | Game *Game :: createGame( SFCave *p, int w, int h, string game, string difficulty ) | 313 | Game *Game :: createGame( SFCave *p, int w, int h, string game, string difficulty ) |
318 | { | 314 | { |
319 | Game *g; | 315 | Game *g; |
320 | 316 | ||
321 | if ( game == "SFCave" ) | 317 | if ( game == "SFCave" ) |
322 | g = new SFCaveGame( p, w, h, 0 ); | 318 | g = new SFCaveGame( p, w, h, 0 ); |
323 | else if ( game == "Gates" ) | 319 | else if ( game == "Gates" ) |
324 | g = new GatesGame( p, w, h, 0 ); | 320 | g = new GatesGame( p, w, h, 0 ); |
325 | else if ( game == "Fly" ) | 321 | else if ( game == "Fly" ) |
diff --git a/noncore/games/sfcave-sdl/game.h b/noncore/games/sfcave-sdl/game.h index 56fa6a1..087f848 100644 --- a/noncore/games/sfcave-sdl/game.h +++ b/noncore/games/sfcave-sdl/game.h | |||
@@ -16,67 +16,66 @@ public: | |||
16 | virtual ~Game(); | 16 | virtual ~Game(); |
17 | 17 | ||
18 | virtual void init( ); | 18 | virtual void init( ); |
19 | virtual void update( int state ); | 19 | virtual void update( int state ); |
20 | virtual void preDraw( SDL_Surface * ); | 20 | virtual void preDraw( SDL_Surface * ); |
21 | virtual void draw( SDL_Surface * ); | 21 | virtual void draw( SDL_Surface * ); |
22 | 22 | ||
23 | virtual void stateChanged( int from, int to ); | 23 | virtual void stateChanged( int from, int to ); |
24 | 24 | ||
25 | void setReplay( bool val ) { replay = val; } | 25 | void setReplay( bool val ) { replay = val; } |
26 | 26 | ||
27 | void handleKeys( SDL_KeyboardEvent &key ); | 27 | void handleKeys( SDL_KeyboardEvent &key ); |
28 | QString getGameName() { return gameName; } | 28 | string getGameName() { return gameName; } |
29 | int getDifficulty() { return difficulty; } | 29 | int getDifficulty() { return difficulty; } |
30 | QString getGameDifficultyText(); | 30 | string getGameDifficultyText(); |
31 | void setDifficulty( int diff ) { difficulty = diff; } | 31 | void setDifficulty( int diff ); |
32 | void setDifficulty( string diff ); | 32 | void setDifficulty( string diff ); |
33 | 33 | ||
34 | long getScore() { return score; } | 34 | long getScore() { return score; } |
35 | long getHighScore() { return highScore; } | 35 | long getHighScore() { return highScore; } |
36 | void increaseScore( long val ) { score += val; } | 36 | void increaseScore( long val ) { score += val; } |
37 | void clearScore() { score = 0; } | 37 | void clearScore() { score = 0; } |
38 | bool gotHighScore() { return (score >= highScore); } | 38 | bool gotHighScore() { return (score >= highScore); } |
39 | bool isReplayAvailable() { return replayList.size() > 0; } | 39 | bool isReplayAvailable() { return replayList.size() > 0; } |
40 | 40 | ||
41 | Terrain *getTerrain() { return terrain; } | 41 | Terrain *getTerrain() { return terrain; } |
42 | Player *getPlayer() { return player; } | ||
42 | 43 | ||
43 | void setSeed( int seed ); | 44 | void setSeed( int seed ); |
44 | void loadReplay( QString file ); | 45 | void loadReplay( string file ); |
45 | void saveReplay( QString file ); | 46 | void saveReplay( string file ); |
46 | 47 | ||
47 | static Game *createGame( SFCave *p, int w, int h, string game, string difficulty ); | 48 | static Game *createGame( SFCave *p, int w, int h, string game, string difficulty ); |
48 | 49 | ||
49 | protected: | 50 | protected: |
50 | QString gameName; | 51 | string gameName; |
51 | 52 | ||
52 | int thrustChannel; | 53 | int thrustChannel; |
53 | 54 | ||
54 | int difficulty; | 55 | int difficulty; |
55 | 56 | ||
56 | SFCave *parent; | 57 | SFCave *parent; |
57 | Terrain *terrain; | 58 | Terrain *terrain; |
58 | Player *player; | 59 | Player *player; |
59 | 60 | ||
60 | int nrFrames; | 61 | int nrFrames; |
61 | 62 | ||
62 | bool press; | 63 | bool press; |
63 | 64 | ||
64 | int sHeight; | 65 | int sHeight; |
65 | int sWidth; | 66 | int sWidth; |
66 | long score; | 67 | long score; |
67 | long highScore; | 68 | long highScore; |
68 | 69 | ||
69 | // Stuff for the replays | 70 | // Stuff for the replays |
70 | int currentSeed; | 71 | int currentSeed; |
71 | 72 | ||
72 | // QListIterator<int> *replayIt; | ||
73 | list<int> replayList; | 73 | list<int> replayList; |
74 | list<int>::iterator replayIt; | 74 | list<int>::iterator replayIt; |
75 | //QList<int> replayList; | ||
76 | bool replay; | 75 | bool replay; |
77 | QString replayFile; | 76 | string replayFile; |
78 | 77 | ||
79 | private: | 78 | private: |
80 | }; | 79 | }; |
81 | 80 | ||
82 | #endif | 81 | #endif |
diff --git a/noncore/games/sfcave-sdl/gates_game.cpp b/noncore/games/sfcave-sdl/gates_game.cpp index 1a9bc89..762801d 100644 --- a/noncore/games/sfcave-sdl/gates_game.cpp +++ b/noncore/games/sfcave-sdl/gates_game.cpp | |||
@@ -9,24 +9,25 @@ GatesGame :: GatesGame( SFCave *p, int w, int h, int diff ) | |||
9 | { | 9 | { |
10 | gameName = "Gates"; | 10 | gameName = "Gates"; |
11 | difficulty = MENU_DIFFICULTY_EASY; | 11 | difficulty = MENU_DIFFICULTY_EASY; |
12 | blockUpdateRate = 200; | 12 | blockUpdateRate = 200; |
13 | 13 | ||
14 | terrain = new Terrain( w, h ); | 14 | terrain = new Terrain( w, h ); |
15 | player = new Player( w, h ); | 15 | player = new Player( w, h ); |
16 | highScore = 0; | 16 | highScore = 0; |
17 | } | 17 | } |
18 | 18 | ||
19 | GatesGame :: ~GatesGame() | 19 | GatesGame :: ~GatesGame() |
20 | { | 20 | { |
21 | // terrain and player get deleted by parent class | ||
21 | } | 22 | } |
22 | 23 | ||
23 | void GatesGame :: init() | 24 | void GatesGame :: init() |
24 | { | 25 | { |
25 | Game :: init(); | 26 | Game :: init(); |
26 | 27 | ||
27 | blockHeight = 80; | 28 | blockHeight = 80; |
28 | blockWidth = 20; | 29 | blockWidth = 20; |
29 | lastGateBottomY = 0; | 30 | lastGateBottomY = 0; |
30 | 31 | ||
31 | gateDistance = 75; | 32 | gateDistance = 75; |
32 | nextGate = nextInt( 50 ) + gateDistance; | 33 | nextGate = nextInt( 50 ) + gateDistance; |
@@ -37,24 +38,37 @@ void GatesGame :: init() | |||
37 | case MENU_DIFFICULTY_EASY: | 38 | case MENU_DIFFICULTY_EASY: |
38 | gapHeight = 75; | 39 | gapHeight = 75; |
39 | player->setMovementInfo( 0.4, 0.6, 4, 5 ); | 40 | player->setMovementInfo( 0.4, 0.6, 4, 5 ); |
40 | break; | 41 | break; |
41 | case MENU_DIFFICULTY_NORMAL: | 42 | case MENU_DIFFICULTY_NORMAL: |
42 | gapHeight = 50; | 43 | gapHeight = 50; |
43 | player->setMovementInfo( 0.4, 0.6, 4, 5 ); | 44 | player->setMovementInfo( 0.4, 0.6, 4, 5 ); |
44 | break; | 45 | break; |
45 | case MENU_DIFFICULTY_HARD: | 46 | case MENU_DIFFICULTY_HARD: |
46 | gapHeight = 25; | 47 | gapHeight = 25; |
47 | player->setMovementInfo( 0.6, 0.8, 6, 7 ); | 48 | player->setMovementInfo( 0.6, 0.8, 6, 7 ); |
48 | break; | 49 | break; |
50 | case MENU_DIFFICULTY_CUSTOM: | ||
51 | { | ||
52 | // Read custom difficulty settings for this game | ||
53 | gapHeight = parent->loadIntSetting( "Gates_custom_gapHeight", 75 ); | ||
54 | |||
55 | double thrust = parent->loadDoubleSetting( "Gates_custom_player_thrust", 0.4 ); | ||
56 | double gravity = parent->loadDoubleSetting( "Gates_custom_player_gravity", 0.6 ); | ||
57 | double maxUp = parent->loadDoubleSetting( "Gates_custom_player_maxupspeed", 4.0 ); | ||
58 | double maxDown = parent->loadDoubleSetting( "Gates_custom_player_maxdownspeed", 5.0 ); | ||
59 | player->setMovementInfo( thrust, gravity, maxUp, maxDown ); | ||
60 | |||
61 | break; | ||
62 | } | ||
49 | } | 63 | } |
50 | 64 | ||
51 | for ( int i = 0 ; i < BLOCKSIZE ; ++i ) | 65 | for ( int i = 0 ; i < BLOCKSIZE ; ++i ) |
52 | blocks[i].y( -1 ); | 66 | blocks[i].y( -1 ); |
53 | } | 67 | } |
54 | 68 | ||
55 | void GatesGame :: update( int state ) | 69 | void GatesGame :: update( int state ) |
56 | { | 70 | { |
57 | Game::update( state ); | 71 | Game::update( state ); |
58 | 72 | ||
59 | // Game logic goes here | 73 | // Game logic goes here |
60 | if ( state == STATE_PLAYING ) | 74 | if ( state == STATE_PLAYING ) |
@@ -68,25 +82,24 @@ void GatesGame :: update( int state ) | |||
68 | gapHeight -= 5; | 82 | gapHeight -= 5; |
69 | } | 83 | } |
70 | 84 | ||
71 | // Slightly random gap distance | 85 | // Slightly random gap distance |
72 | if ( nrFrames >= nextGate ) | 86 | if ( nrFrames >= nextGate ) |
73 | { | 87 | { |
74 | nextGate = nrFrames + nextInt( 50 ) + gateDistance; | 88 | nextGate = nrFrames + nextInt( 50 ) + gateDistance; |
75 | addGate(); | 89 | addGate(); |
76 | } | 90 | } |
77 | 91 | ||
78 | if ( checkCollisions() ) | 92 | if ( checkCollisions() ) |
79 | { | 93 | { |
80 | // printf( "Crashed!\n" ); | ||
81 | parent->changeState( STATE_CRASHING ); | 94 | parent->changeState( STATE_CRASHING ); |
82 | return; | 95 | return; |
83 | } | 96 | } |
84 | 97 | ||
85 | terrain->moveTerrain( 5 ); | 98 | terrain->moveTerrain( 5 ); |
86 | moveBlocks( 5 ); | 99 | moveBlocks( 5 ); |
87 | player->move( press ); | 100 | player->move( press ); |
88 | } | 101 | } |
89 | } | 102 | } |
90 | 103 | ||
91 | void GatesGame :: draw( SDL_Surface *screen ) | 104 | void GatesGame :: draw( SDL_Surface *screen ) |
92 | { | 105 | { |
diff --git a/noncore/games/sfcave-sdl/help.cpp b/noncore/games/sfcave-sdl/help.cpp index 91c62da..f1728f6 100644 --- a/noncore/games/sfcave-sdl/help.cpp +++ b/noncore/games/sfcave-sdl/help.cpp | |||
@@ -48,25 +48,24 @@ void Help :: init() | |||
48 | startPos = 320; | 48 | startPos = 320; |
49 | currLine = 0; | 49 | currLine = 0; |
50 | textSpeed = 1; | 50 | textSpeed = 1; |
51 | 51 | ||
52 | // Create our coloured font | 52 | // Create our coloured font |
53 | FontHandler :: changeColor( FONT_HELP_FONT, 0, 0, 255 ); | 53 | FontHandler :: changeColor( FONT_HELP_FONT, 0, 0, 255 ); |
54 | } | 54 | } |
55 | 55 | ||
56 | void Help :: draw( SDL_Surface *screen ) | 56 | void Help :: draw( SDL_Surface *screen ) |
57 | { | 57 | { |
58 | stars->draw( screen ); | 58 | stars->draw( screen ); |
59 | 59 | ||
60 | |||
61 | list<string>::iterator it = textList.begin(); | 60 | list<string>::iterator it = textList.begin(); |
62 | 61 | ||
63 | // Move to start of text | 62 | // Move to start of text |
64 | for ( int i = 0 ; i < currLine && it != textList.end() ; ++i ) | 63 | for ( int i = 0 ; i < currLine && it != textList.end() ; ++i ) |
65 | it++; | 64 | it++; |
66 | 65 | ||
67 | int pos = startPos; | 66 | int pos = startPos; |
68 | while ( pos < 320 && it != textList.end() ) | 67 | while ( pos < 320 && it != textList.end() ) |
69 | { | 68 | { |
70 | // get next line | 69 | // get next line |
71 | string text = *it; | 70 | string text = *it; |
72 | 71 | ||
diff --git a/noncore/games/sfcave-sdl/menu.cpp b/noncore/games/sfcave-sdl/menu.cpp index 0a7366f..a4a4216 100644 --- a/noncore/games/sfcave-sdl/menu.cpp +++ b/noncore/games/sfcave-sdl/menu.cpp | |||
@@ -1,23 +1,23 @@ | |||
1 | #include <SDL_image.h> | 1 | #include <SDL_image.h> |
2 | #include "SDL_rotozoom.h" | 2 | #include "SDL_rotozoom.h" |
3 | 3 | ||
4 | #include "constants.h" | 4 | #include "constants.h" |
5 | #include "sfcave.h" | 5 | #include "sfcave.h" |
6 | #include "game.h" | 6 | #include "game.h" |
7 | #include "menu.h" | 7 | #include "menu.h" |
8 | #include "font.h" | 8 | #include "font.h" |
9 | #include "starfield.h" | 9 | #include "starfield.h" |
10 | 10 | ||
11 | MenuOption :: MenuOption( QString text, int id ) | 11 | MenuOption :: MenuOption( string text, int id ) |
12 | { | 12 | { |
13 | menuText = text; | 13 | menuText = text; |
14 | menuId = id; | 14 | menuId = id; |
15 | nextMenu = 0; | 15 | nextMenu = 0; |
16 | highlighted = false; | 16 | highlighted = false; |
17 | } | 17 | } |
18 | 18 | ||
19 | MenuOption :: ~MenuOption() | 19 | MenuOption :: ~MenuOption() |
20 | { | 20 | { |
21 | } | 21 | } |
22 | 22 | ||
23 | 23 | ||
@@ -106,45 +106,70 @@ Menu :: Menu( SFCave *p ) | |||
106 | Menu *gameType = new Menu( options ); | 106 | Menu *gameType = new Menu( options ); |
107 | item = gameType->addMenuOption( "SFCave", MENU_GAME_SFCAVE ); | 107 | item = gameType->addMenuOption( "SFCave", MENU_GAME_SFCAVE ); |
108 | item->setNextMenu( options ); | 108 | item->setNextMenu( options ); |
109 | item = gameType->addMenuOption( "Gates", MENU_GAME_GATES ); | 109 | item = gameType->addMenuOption( "Gates", MENU_GAME_GATES ); |
110 | item->setNextMenu( options ); | 110 | item->setNextMenu( options ); |
111 | item = gameType->addMenuOption( "Fly", MENU_GAME_FLY ); | 111 | item = gameType->addMenuOption( "Fly", MENU_GAME_FLY ); |
112 | item->setNextMenu( options ); | 112 | item->setNextMenu( options ); |
113 | item = gameType->addMenuOption( "Back", MENU_BACK ); | 113 | item = gameType->addMenuOption( "Back", MENU_BACK ); |
114 | item->setNextMenu( options ); | 114 | item->setNextMenu( options ); |
115 | typeMenu->setNextMenu( gameType ); | 115 | typeMenu->setNextMenu( gameType ); |
116 | 116 | ||
117 | // Game Difficulty menu | 117 | // Game Difficulty menu |
118 | MenuOption *customMenu = 0; | ||
118 | Menu *gameDifficulty = new Menu( options ); | 119 | Menu *gameDifficulty = new Menu( options ); |
119 | item = gameDifficulty->addMenuOption( "Easy", MENU_DIFFICULTY_EASY ); | 120 | item = gameDifficulty->addMenuOption( "Easy", MENU_DIFFICULTY_EASY ); |
120 | item->setNextMenu( options, false ); | 121 | item->setNextMenu( options, false ); |
121 | item = gameDifficulty->addMenuOption( "Normal", MENU_DIFFICULTY_NORMAL ); | 122 | item = gameDifficulty->addMenuOption( "Normal", MENU_DIFFICULTY_NORMAL ); |
122 | item->setNextMenu( options, false ); | 123 | item->setNextMenu( options, false ); |
123 | item = gameDifficulty->addMenuOption( "Hard", MENU_DIFFICULTY_HARD ); | 124 | item = gameDifficulty->addMenuOption( "Hard", MENU_DIFFICULTY_HARD ); |
124 | item->setNextMenu( options, false ); | 125 | item->setNextMenu( options, false ); |
126 | customMenu = gameDifficulty->addMenuOption( "Custom", MENU_DIFFICULTY_CUSTOM ); | ||
125 | item = gameDifficulty->addMenuOption( "Back", MENU_BACK ); | 127 | item = gameDifficulty->addMenuOption( "Back", MENU_BACK ); |
126 | item->setNextMenu( options, false ); | 128 | item->setNextMenu( options, false ); |
127 | difficultyMenu->setNextMenu( gameDifficulty ); | 129 | difficultyMenu->setNextMenu( gameDifficulty ); |
128 | 130 | ||
129 | // Sounds Menu | 131 | // Sounds Menu |
130 | Menu *sounds = new Menu( options ); | 132 | Menu *sounds = new Menu( options ); |
131 | sounds->addMenuOption( "Sound On", MENU_SOUND_ON ); | 133 | sounds->addMenuOption( "Sound On", MENU_SOUND_ON ); |
132 | sounds->addMenuOption( "Sound Off", MENU_SOUND_OFF ); | 134 | sounds->addMenuOption( "Sound Off", MENU_SOUND_OFF ); |
133 | sounds->addMenuOption( "Music On", MENU_MUSIC_ON ); | 135 | sounds->addMenuOption( "Music On", MENU_MUSIC_ON ); |
134 | sounds->addMenuOption( "Music Off", MENU_MUSIC_OFF ); | 136 | sounds->addMenuOption( "Music Off", MENU_MUSIC_OFF ); |
135 | item = sounds->addMenuOption( "Back", MENU_BACK ); | 137 | item = sounds->addMenuOption( "Back", MENU_BACK ); |
136 | item->setNextMenu( options, false ); | 138 | item->setNextMenu( options, false ); |
137 | soundsMenu->setNextMenu( sounds ); | 139 | soundsMenu->setNextMenu( sounds ); |
138 | 140 | ||
141 | // Custom Menu | ||
142 | Menu *custom = new Menu( gameDifficulty ); | ||
143 | Menu *updown = new Menu( custom ); | ||
144 | item = custom->addMenuOption( "Thrust", MENU_CUSTOM_THRUST ); | ||
145 | item->setNextMenu( updown ); | ||
146 | item = custom->addMenuOption( "Gravity", MENU_CUSTOM_GRAVITY ); | ||
147 | item->setNextMenu( updown ); | ||
148 | item = custom->addMenuOption( "Max Speed Up", MENU_CUSTOM_MAXSPEEDUP ); | ||
149 | item->setNextMenu( updown ); | ||
150 | item = custom->addMenuOption( "Max Speed Down", MENU_CUSTOM_MAXSPEEDDOWN ); | ||
151 | item->setNextMenu( updown ); | ||
152 | item = custom->addMenuOption( "Back", MENU_BACK ); | ||
153 | item->setNextMenu( gameDifficulty, false ); | ||
154 | customMenu->setNextMenu( custom ); | ||
155 | |||
156 | // Up down menu | ||
157 | item = updown->addMenuOption( "Increase", MENU_CUSTOM_INCREASE ); | ||
158 | item = updown->addMenuOption( "Decrease", MENU_CUSTOM_DECREASE ); | ||
159 | item = updown->addMenuOption( "Save", MENU_CUSTOM_SAVE ); | ||
160 | item->setNextMenu( custom, false ); | ||
161 | item = updown->addMenuOption( "Cancel", MENU_CUSTOM_CANCEL ); | ||
162 | item->setNextMenu( custom, false ); | ||
163 | |||
139 | // Set static variables for menu selection up | 164 | // Set static variables for menu selection up |
140 | mainMenu = this; | 165 | mainMenu = this; |
141 | currentMenuOption = 0; | 166 | currentMenuOption = 0; |
142 | 167 | ||
143 | resetToTopMenu(); | 168 | resetToTopMenu(); |
144 | 169 | ||
145 | angle = 0; | 170 | angle = 0; |
146 | 171 | ||
147 | stars = new StarField; | 172 | stars = new StarField; |
148 | } | 173 | } |
149 | 174 | ||
150 | // This is a private constructor used for creating sub menus - only called by the Master Menu | 175 | // This is a private constructor used for creating sub menus - only called by the Master Menu |
@@ -206,25 +231,24 @@ void Menu :: draw( SDL_Surface *screen ) | |||
206 | list<MenuOption *>::iterator it; | 231 | list<MenuOption *>::iterator it; |
207 | for ( it = currentMenu->listItems.begin(); it != currentMenu->listItems.end() ; ++it ) | 232 | for ( it = currentMenu->listItems.begin(); it != currentMenu->listItems.end() ; ++it ) |
208 | { | 233 | { |
209 | y += (*it)->draw( screen, y ) + 2; | 234 | y += (*it)->draw( screen, y ) + 2; |
210 | } | 235 | } |
211 | } | 236 | } |
212 | 237 | ||
213 | int Menu :: handleKeys( SDL_KeyboardEvent &key ) | 238 | int Menu :: handleKeys( SDL_KeyboardEvent &key ) |
214 | { | 239 | { |
215 | if ( key.type != SDL_KEYDOWN ) | 240 | if ( key.type != SDL_KEYDOWN ) |
216 | return -1; | 241 | return -1; |
217 | 242 | ||
218 | statusText = ""; | ||
219 | switch( key.keysym.sym ) | 243 | switch( key.keysym.sym ) |
220 | { | 244 | { |
221 | case SDLK_DOWN: | 245 | case SDLK_DOWN: |
222 | { | 246 | { |
223 | // Move to next menu item | 247 | // Move to next menu item |
224 | currentMenu->currentMenuOption->highlight( false ); | 248 | currentMenu->currentMenuOption->highlight( false ); |
225 | 249 | ||
226 | list<MenuOption *>::iterator it; | 250 | list<MenuOption *>::iterator it; |
227 | for ( it = currentMenu->listItems.begin(); it != currentMenu->listItems.end() ; ++it ) | 251 | for ( it = currentMenu->listItems.begin(); it != currentMenu->listItems.end() ; ++it ) |
228 | { | 252 | { |
229 | if ( (*it) == currentMenu->currentMenuOption ) | 253 | if ( (*it) == currentMenu->currentMenuOption ) |
230 | { | 254 | { |
@@ -267,62 +291,61 @@ int Menu :: handleKeys( SDL_KeyboardEvent &key ) | |||
267 | if ( reachedBeginning ) | 291 | if ( reachedBeginning ) |
268 | currentMenu->currentMenuOption = currentMenu->listItems.back(); | 292 | currentMenu->currentMenuOption = currentMenu->listItems.back(); |
269 | else | 293 | else |
270 | currentMenu->currentMenuOption = *it; | 294 | currentMenu->currentMenuOption = *it; |
271 | 295 | ||
272 | currentMenu->currentMenuOption->highlight( true ); | 296 | currentMenu->currentMenuOption->highlight( true ); |
273 | 297 | ||
274 | break; | 298 | break; |
275 | } | 299 | } |
276 | case SDLK_LEFT: | 300 | case SDLK_LEFT: |
277 | if ( currentMenu->parentMenu != 0 ) | 301 | if ( currentMenu->parentMenu != 0 ) |
278 | { | 302 | { |
303 | statusText = ""; | ||
279 | currentMenu = currentMenu->parentMenu; | 304 | currentMenu = currentMenu->parentMenu; |
280 | printf( "HERE\n" ); | ||
281 | 305 | ||
282 | return -1; | 306 | return -1; |
283 | } | 307 | } |
284 | break; | 308 | break; |
285 | 309 | ||
286 | case SDLK_RETURN: | 310 | case SDLK_RETURN: |
287 | case SDLK_SPACE: | 311 | case SDLK_SPACE: |
288 | { | 312 | { |
313 | statusText = ""; | ||
289 | // select menu item | 314 | // select menu item |
290 | int id = currentMenu->currentMenuOption->getMenuId(); | 315 | int id = currentMenu->currentMenuOption->getMenuId(); |
291 | // // if the current item has a child menu then move to that menu | 316 | |
317 | // if the current item has a child menu then move to that menu | ||
292 | Menu *next = currentMenu->currentMenuOption->getNextMenu(); | 318 | Menu *next = currentMenu->currentMenuOption->getNextMenu(); |
293 | if ( next != 0 ) | 319 | if ( next != 0 ) |
294 | { | 320 | { |
295 | bool down = currentMenu->currentMenuOption->isDownMenuTree(); | 321 | bool down = currentMenu->currentMenuOption->isDownMenuTree(); |
296 | currentMenu = next; | 322 | currentMenu = next; |
297 | if ( down ) | 323 | if ( down ) |
298 | initCurrentMenu(); | 324 | initCurrentMenu(); |
299 | // return -1; | ||
300 | } | 325 | } |
301 | // else | 326 | |
302 | { | ||
303 | return id; | 327 | return id; |
304 | } | ||
305 | 328 | ||
306 | break; | 329 | break; |
307 | } | 330 | } |
308 | 331 | ||
309 | default: | 332 | default: |
310 | break; | 333 | break; |
311 | } | 334 | } |
312 | 335 | ||
313 | return -1; | 336 | return -1; |
314 | } | 337 | } |
315 | 338 | ||
316 | MenuOption *Menu :: addMenuOption( QString text, int id ) | 339 | MenuOption *Menu :: addMenuOption( string text, int id ) |
317 | { | 340 | { |
318 | MenuOption *item = new MenuOption( text, id ); | 341 | MenuOption *item = new MenuOption( text, id ); |
319 | 342 | ||
320 | listItems.push_back( item ); | 343 | listItems.push_back( item ); |
321 | 344 | ||
322 | return item; | 345 | return item; |
323 | } | 346 | } |
324 | 347 | ||
325 | void Menu :: resetToTopMenu() | 348 | void Menu :: resetToTopMenu() |
326 | { | 349 | { |
327 | currentMenu = mainMenu; | 350 | currentMenu = mainMenu; |
328 | initCurrentMenu(); | 351 | initCurrentMenu(); |
diff --git a/noncore/games/sfcave-sdl/menu.h b/noncore/games/sfcave-sdl/menu.h index 08f7528..6a5ef40 100644 --- a/noncore/games/sfcave-sdl/menu.h +++ b/noncore/games/sfcave-sdl/menu.h | |||
@@ -4,68 +4,68 @@ | |||
4 | #include <list> | 4 | #include <list> |
5 | using namespace std; | 5 | using namespace std; |
6 | 6 | ||
7 | #include <SDL.h> | 7 | #include <SDL.h> |
8 | 8 | ||
9 | class SFCave; | 9 | class SFCave; |
10 | class StarField; | 10 | class StarField; |
11 | class Menu; | 11 | class Menu; |
12 | 12 | ||
13 | class MenuOption | 13 | class MenuOption |
14 | { | 14 | { |
15 | public: | 15 | public: |
16 | MenuOption( QString text, int id ); | 16 | MenuOption( string text, int id ); |
17 | ~MenuOption(); | 17 | ~MenuOption(); |
18 | 18 | ||
19 | void highlight( bool val ) { highlighted = val; } | 19 | void highlight( bool val ) { highlighted = val; } |
20 | int draw( SDL_Surface *screen, int y ); | 20 | int draw( SDL_Surface *screen, int y ); |
21 | void setNextMenu( Menu *item, bool down = true ); | 21 | void setNextMenu( Menu *item, bool down = true ); |
22 | Menu *getNextMenu() { return nextMenu; } | 22 | Menu *getNextMenu() { return nextMenu; } |
23 | int getMenuId() { return menuId; } | 23 | int getMenuId() { return menuId; } |
24 | bool isDownMenuTree() { return downMenuTree; } | 24 | bool isDownMenuTree() { return downMenuTree; } |
25 | 25 | ||
26 | private: | 26 | private: |
27 | int menuId; | 27 | int menuId; |
28 | QString menuText; | 28 | string menuText; |
29 | bool highlighted; | 29 | bool highlighted; |
30 | bool downMenuTree; | 30 | bool downMenuTree; |
31 | 31 | ||
32 | Menu *nextMenu; | 32 | Menu *nextMenu; |
33 | }; | 33 | }; |
34 | 34 | ||
35 | class Menu | 35 | class Menu |
36 | { | 36 | { |
37 | public: | 37 | public: |
38 | Menu( SFCave *p ); | 38 | Menu( SFCave *p ); |
39 | ~Menu(); | 39 | ~Menu(); |
40 | 40 | ||
41 | void draw( SDL_Surface *screen ); | 41 | void draw( SDL_Surface *screen ); |
42 | int handleKeys( SDL_KeyboardEvent & ); | 42 | int handleKeys( SDL_KeyboardEvent & ); |
43 | MenuOption *addMenuOption( QString text, int id ); | 43 | MenuOption *addMenuOption( string text, int id ); |
44 | void resetToTopMenu(); | 44 | void resetToTopMenu(); |
45 | void initCurrentMenu(); | 45 | void initCurrentMenu(); |
46 | 46 | ||
47 | void setStatusText( QString text ) { statusText = text; } | 47 | void setStatusText( string text ) { statusText = text; } |
48 | 48 | ||
49 | protected: | 49 | protected: |
50 | 50 | ||
51 | private: | 51 | private: |
52 | static SDL_Surface * sfcaveTextImage; | 52 | static SDL_Surface * sfcaveTextImage; |
53 | int angle; | 53 | int angle; |
54 | 54 | ||
55 | static Menu *mainMenu; | 55 | static Menu *mainMenu; |
56 | static Menu *currentMenu; | 56 | static Menu *currentMenu; |
57 | Menu *parentMenu; | 57 | Menu *parentMenu; |
58 | 58 | ||
59 | StarField *stars; | 59 | StarField *stars; |
60 | 60 | ||
61 | QString statusText; | 61 | string statusText; |
62 | 62 | ||
63 | SFCave *parent; | 63 | SFCave *parent; |
64 | list<MenuOption *> listItems; | 64 | list<MenuOption *> listItems; |
65 | MenuOption *currentMenuOption; | 65 | MenuOption *currentMenuOption; |
66 | 66 | ||
67 | Menu( Menu* p ); | 67 | Menu( Menu* p ); |
68 | }; | 68 | }; |
69 | 69 | ||
70 | 70 | ||
71 | #endif | 71 | #endif |
diff --git a/noncore/games/sfcave-sdl/player.cpp b/noncore/games/sfcave-sdl/player.cpp index 830ee78..2d52ae2 100644 --- a/noncore/games/sfcave-sdl/player.cpp +++ b/noncore/games/sfcave-sdl/player.cpp | |||
@@ -2,26 +2,26 @@ | |||
2 | #include "SDL_gfxPrimitives.h" | 2 | #include "SDL_gfxPrimitives.h" |
3 | 3 | ||
4 | #include "constants.h" | 4 | #include "constants.h" |
5 | #include "player.h" | 5 | #include "player.h" |
6 | #include "random.h" | 6 | #include "random.h" |
7 | #include "animatedimage.h" | 7 | #include "animatedimage.h" |
8 | 8 | ||
9 | Player :: Player( int w, int h ) | 9 | Player :: Player( int w, int h ) |
10 | { | 10 | { |
11 | sWidth = w; | 11 | sWidth = w; |
12 | sHeight = h; | 12 | sHeight = h; |
13 | 13 | ||
14 | thrustUp = 0.4; | 14 | thrust = 0.4; |
15 | thrustDown = 0.6; | 15 | gravity = 0.6; |
16 | maxUpSpeed = 4.0; | 16 | maxUpSpeed = 4.0; |
17 | maxDownSpeed = 5.0; | 17 | maxDownSpeed = 5.0; |
18 | 18 | ||
19 | explosion = new AnimatedImage( IMAGES_PATH "explosion.bmp", 15 ); | 19 | explosion = new AnimatedImage( IMAGES_PATH "explosion.bmp", 15 ); |
20 | init(); | 20 | init(); |
21 | } | 21 | } |
22 | 22 | ||
23 | Player :: ~Player() | 23 | Player :: ~Player() |
24 | { | 24 | { |
25 | if ( explosion ) | 25 | if ( explosion ) |
26 | delete explosion; | 26 | delete explosion; |
27 | } | 27 | } |
@@ -71,49 +71,46 @@ void Player :: draw( SDL_Surface *screen ) | |||
71 | } | 71 | } |
72 | } | 72 | } |
73 | 73 | ||
74 | void Player :: drawTrails( SDL_Surface *screen ) | 74 | void Player :: drawTrails( SDL_Surface *screen ) |
75 | { | 75 | { |
76 | if ( allFaded && crashing ) | 76 | if ( allFaded && crashing ) |
77 | return; | 77 | return; |
78 | 78 | ||
79 | for ( int i = 0 ; i < TRAILSIZE ; ++i ) | 79 | for ( int i = 0 ; i < TRAILSIZE ; ++i ) |
80 | { | 80 | { |
81 | if ( trail[i].x() >= 0 ) | 81 | if ( trail[i].x() >= 0 ) |
82 | { | 82 | { |
83 | // int r = (int) ((255.0/pos.x()) * (trail[i].x)); | ||
84 | // int g = (int) ((150.0/pos.x()) * (trail[i].x)); | ||
85 | int c = (int)((150.0/50) * (50.0 - (pos.x() - trail[i].x() ) )); | 83 | int c = (int)((150.0/50) * (50.0 - (pos.x() - trail[i].x() ) )); |
86 | // SDL_FillRect( screen, &trail[i], SDL_MapRGBA( screen->format, r, g, 0, 0 ) ); //(int)(1.5*c), 0, 255 ) ); | ||
87 | boxRGBA( screen, trail[i].x(), trail[i].y(), trail[i].x() + 2, trail[i].y() + 2, 255, (int)(1.5*c), 0, c ); | 84 | boxRGBA( screen, trail[i].x(), trail[i].y(), trail[i].x() + 2, trail[i].y() + 2, 255, (int)(1.5*c), 0, c ); |
88 | } | 85 | } |
89 | } | 86 | } |
90 | } | 87 | } |
91 | 88 | ||
92 | void Player :: move( bool up ) | 89 | void Player :: move( bool up ) |
93 | { | 90 | { |
94 | // Find enpty trail and move others | 91 | // Find enpty trail and move others |
95 | moveTrails(); | 92 | moveTrails(); |
96 | 93 | ||
97 | if ( up ) | 94 | if ( up ) |
98 | thrust -= thrustUp; | 95 | currentThrust -= thrust; |
99 | else | 96 | else |
100 | thrust += thrustDown; | 97 | currentThrust += gravity; |
101 | 98 | ||
102 | if ( thrust > maxDownSpeed ) | 99 | if ( currentThrust > maxDownSpeed ) |
103 | thrust = maxDownSpeed; | 100 | currentThrust = maxDownSpeed; |
104 | else if ( thrust < -maxUpSpeed ) | 101 | else if ( currentThrust < -maxUpSpeed ) |
105 | thrust = -maxUpSpeed; | 102 | currentThrust = -maxUpSpeed; |
106 | 103 | ||
107 | pos.moveBy( 0, (int)(thrust) ); | 104 | pos.moveBy( 0, (int)(currentThrust) ); |
108 | } | 105 | } |
109 | 106 | ||
110 | void Player :: moveTrails() | 107 | void Player :: moveTrails() |
111 | { | 108 | { |
112 | bool done = false; | 109 | bool done = false; |
113 | bool stillVisible = false; | 110 | bool stillVisible = false; |
114 | 111 | ||
115 | // Dont do anything here if all faded when were crashing | 112 | // Dont do anything here if all faded when were crashing |
116 | if ( allFaded && crashing ) | 113 | if ( allFaded && crashing ) |
117 | return; | 114 | return; |
118 | 115 | ||
119 | for ( int i = 0 ; i < TRAILSIZE ; ++i ) | 116 | for ( int i = 0 ; i < TRAILSIZE ; ++i ) |
@@ -143,20 +140,145 @@ bool Player :: updateCrashing() | |||
143 | moveTrails(); | 140 | moveTrails(); |
144 | if ( expNextFrame ) | 141 | if ( expNextFrame ) |
145 | { | 142 | { |
146 | expNextFrame = false; | 143 | expNextFrame = false; |
147 | crashed = !explosion->nextFrame(); | 144 | crashed = !explosion->nextFrame(); |
148 | } | 145 | } |
149 | else | 146 | else |
150 | expNextFrame = true; | 147 | expNextFrame = true; |
151 | 148 | ||
152 | return crashed; | 149 | return crashed; |
153 | } | 150 | } |
154 | 151 | ||
155 | void Player :: setMovementInfo( double up, double down, double maxUp, double maxDown ) | 152 | void Player :: setMovementInfo( double up, double grav, double maxUp, double maxDown ) |
156 | { | 153 | { |
157 | thrustUp = up; | 154 | thrust = up; |
158 | thrustDown = down; | 155 | gravity = grav; |
159 | maxUpSpeed = maxUp; | 156 | maxUpSpeed = maxUp; |
160 | maxDownSpeed = maxDown; | 157 | maxDownSpeed = maxDown; |
161 | } | 158 | } |
162 | 159 | ||
160 | |||
161 | void Player :: incValue( int valueType ) | ||
162 | { | ||
163 | switch( valueType ) | ||
164 | { | ||
165 | case PLAYER_THRUST: | ||
166 | thrust += 0.1; | ||
167 | break; | ||
168 | case PLAYER_GRAVITY: | ||
169 | gravity += 0.1; | ||
170 | break; | ||
171 | case PLAYER_MAX_SPEED_UP: | ||
172 | maxUpSpeed += 0.1; | ||
173 | break; | ||
174 | case PLAYER_MAX_SPEED_DOWN: | ||
175 | maxDownSpeed += 0.1; | ||
176 | break; | ||
177 | } | ||
178 | } | ||
179 | |||
180 | void Player :: decValue( int valueType ) | ||
181 | { | ||
182 | switch( valueType ) | ||
183 | { | ||
184 | case PLAYER_THRUST: | ||
185 | thrust -= 0.1; | ||
186 | break; | ||
187 | case PLAYER_GRAVITY: | ||
188 | gravity -= 0.1; | ||
189 | break; | ||
190 | case PLAYER_MAX_SPEED_UP: | ||
191 | maxUpSpeed -= 0.1; | ||
192 | break; | ||
193 | case PLAYER_MAX_SPEED_DOWN: | ||
194 | maxDownSpeed -= 0.1; | ||
195 | break; | ||
196 | } | ||
197 | } | ||
198 | |||
199 | void Player :: setValue( int valueType, double val ) | ||
200 | { | ||
201 | switch( valueType ) | ||
202 | { | ||
203 | case PLAYER_THRUST: | ||
204 | thrust = val; | ||
205 | break; | ||
206 | case PLAYER_GRAVITY: | ||
207 | gravity = val; | ||
208 | break; | ||
209 | case PLAYER_MAX_SPEED_UP: | ||
210 | maxUpSpeed = val; | ||
211 | break; | ||
212 | case PLAYER_MAX_SPEED_DOWN: | ||
213 | maxDownSpeed = val; | ||
214 | break; | ||
215 | } | ||
216 | } | ||
217 | |||
218 | double Player :: getValue( int valueType ) | ||
219 | { | ||
220 | double val; | ||
221 | switch( valueType ) | ||
222 | { | ||
223 | case PLAYER_THRUST: | ||
224 | val = thrust; | ||
225 | break; | ||
226 | case PLAYER_GRAVITY: | ||
227 | val = gravity; | ||
228 | break; | ||
229 | case PLAYER_MAX_SPEED_UP: | ||
230 | val = maxUpSpeed; | ||
231 | break; | ||
232 | case PLAYER_MAX_SPEED_DOWN: | ||
233 | val = maxDownSpeed; | ||
234 | break; | ||
235 | } | ||
236 | |||
237 | return val; | ||
238 | } | ||
239 | |||
240 | string Player :: getValueTypeString( int valueType ) | ||
241 | { | ||
242 | string val; | ||
243 | switch( valueType ) | ||
244 | { | ||
245 | case PLAYER_THRUST: | ||
246 | val = "thrust"; | ||
247 | break; | ||
248 | case PLAYER_GRAVITY: | ||
249 | val = "gravity"; | ||
250 | break; | ||
251 | case PLAYER_MAX_SPEED_UP: | ||
252 | val = "maxupspeed"; | ||
253 | break; | ||
254 | case PLAYER_MAX_SPEED_DOWN: | ||
255 | val = "maxdownspeed"; | ||
256 | break; | ||
257 | } | ||
258 | |||
259 | return val; | ||
260 | } | ||
261 | |||
262 | string Player :: getValueString( int valueType ) | ||
263 | { | ||
264 | char val[50]; | ||
265 | switch( valueType ) | ||
266 | { | ||
267 | case PLAYER_THRUST: | ||
268 | sprintf( val, "Thrust - %lf", thrust ); | ||
269 | break; | ||
270 | case PLAYER_GRAVITY: | ||
271 | sprintf( val, "Gravity - %lf", gravity ); | ||
272 | break; | ||
273 | case PLAYER_MAX_SPEED_UP: | ||
274 | sprintf( val, "Max Speed Up - %lf", maxUpSpeed ); | ||
275 | break; | ||
276 | case PLAYER_MAX_SPEED_DOWN: | ||
277 | sprintf( val, "Max Speed Down - %lf", maxDownSpeed ); | ||
278 | break; | ||
279 | } | ||
280 | |||
281 | string ret = val; | ||
282 | return ret; | ||
283 | } | ||
284 | |||
diff --git a/noncore/games/sfcave-sdl/player.h b/noncore/games/sfcave-sdl/player.h index e4c904a..595c25b 100644 --- a/noncore/games/sfcave-sdl/player.h +++ b/noncore/games/sfcave-sdl/player.h | |||
@@ -13,38 +13,44 @@ public: | |||
13 | ~Player(); | 13 | ~Player(); |
14 | 14 | ||
15 | void init(); | 15 | void init(); |
16 | void draw( SDL_Surface *screen ); | 16 | void draw( SDL_Surface *screen ); |
17 | void drawTrails( SDL_Surface *screen ); | 17 | void drawTrails( SDL_Surface *screen ); |
18 | void move( bool up ); | 18 | void move( bool up ); |
19 | void moveTrails(); | 19 | void moveTrails(); |
20 | Rect getPos() { return pos; } | 20 | Rect getPos() { return pos; } |
21 | int getX() { return pos.x(); } | 21 | int getX() { return pos.x(); } |
22 | int getY() { return pos.y(); } | 22 | int getY() { return pos.y(); } |
23 | int getHeight() { return pos.h(); } | 23 | int getHeight() { return pos.h(); } |
24 | bool updateCrashing(); | 24 | bool updateCrashing(); |
25 | void setMovementInfo( double up, double down, double maxUp, double maxDown ); | 25 | void setMovementInfo( double up, double grav, double maxUp, double maxDown ); |
26 | void incValue( int valType ); | ||
27 | void decValue( int valType ); | ||
28 | double getValue( int valueType ); | ||
29 | string getValueString( int valueType ); | ||
30 | string getValueTypeString( int valueType ); | ||
31 | void setValue( int valueType, double val ); | ||
26 | 32 | ||
27 | private: | 33 | private: |
28 | AnimatedImage *explosion; | 34 | AnimatedImage *explosion; |
29 | 35 | ||
30 | int sWidth; | 36 | int sWidth; |
31 | int sHeight; | 37 | int sHeight; |
32 | 38 | ||
33 | bool expNextFrame; | 39 | bool expNextFrame; |
34 | bool allFaded; | 40 | bool allFaded; |
35 | bool crashing; | 41 | bool crashing; |
36 | bool crashed; | 42 | bool crashed; |
37 | int crashLineLength; | 43 | int crashLineLength; |
38 | Rect pos; | 44 | Rect pos; |
39 | double thrust; | 45 | double currentThrust; |
40 | 46 | ||
41 | double thrustUp; | 47 | double thrust; |
42 | double thrustDown; | 48 | double gravity; |
43 | double maxUpSpeed; | 49 | double maxUpSpeed; |
44 | double maxDownSpeed; | 50 | double maxDownSpeed; |
45 | 51 | ||
46 | Rect trail[TRAILSIZE]; | 52 | Rect trail[TRAILSIZE]; |
47 | 53 | ||
48 | }; | 54 | }; |
49 | 55 | ||
50 | #endif | 56 | #endif |
diff --git a/noncore/games/sfcave-sdl/settings.cpp b/noncore/games/sfcave-sdl/settings.cpp index 914c4ec..20cce4f 100644 --- a/noncore/games/sfcave-sdl/settings.cpp +++ b/noncore/games/sfcave-sdl/settings.cpp | |||
@@ -1,65 +1,53 @@ | |||
1 | #include <stdio.h> | 1 | #include <stdio.h> |
2 | #include <stdlib.h> | 2 | #include <stdlib.h> |
3 | #include <sys/stat.h> | 3 | #include <sys/stat.h> |
4 | #include <vector> | 4 | #include <vector> |
5 | 5 | ||
6 | #include "settings.h" | 6 | #include "settings.h" |
7 | 7 | ||
8 | // Defined in util.h | ||
9 | string getHomeDir(); | ||
8 | 10 | ||
9 | #define DEFAULT_DIR "." | 11 | #define DEFAULT_DIR "." |
10 | #define DEFAULT_FILE "Settings.cfg" | 12 | #define DEFAULT_FILE "Settings.cfg" |
11 | #define MAX_LINE_SIZE 2048 | 13 | #define MAX_LINE_SIZE 2048 |
12 | 14 | ||
13 | 15 | ||
14 | Settings::Settings( char * env_file, char * env_dir ) | 16 | Settings::Settings( char * env_file, char * env_dir ) |
15 | { | 17 | { |
16 | // Store the correct environment directory | 18 | // Store the correct environment directory |
17 | if (env_dir == NULL) | 19 | if (env_dir == NULL) |
18 | { | 20 | { |
19 | char * homeDir = getenv( "HOME" );; | 21 | envFile = getHomeDir(); |
20 | |||
21 | if ( homeDir ) | ||
22 | { | ||
23 | envFile.append(homeDir); | ||
24 | envFile.append("/"); | 22 | envFile.append("/"); |
25 | } | ||
26 | else | ||
27 | printf( "Environment var HOME not set!\n" ); | ||
28 | 23 | ||
29 | envFile.append(DEFAULT_DIR); | 24 | envFile.append(DEFAULT_DIR); |
30 | } | 25 | } |
31 | else | 26 | else |
32 | envFile.append(env_dir); | 27 | envFile.append(env_dir); |
33 | 28 | ||
34 | envFile.append("/"); | 29 | envFile.append("/"); |
35 | 30 | ||
36 | // Store the correct environment file | 31 | // Store the correct environment file |
37 | if (env_file == NULL) | 32 | if (env_file == NULL) |
38 | envFile.append(DEFAULT_FILE); | 33 | envFile.append(DEFAULT_FILE); |
39 | else | 34 | else |
40 | envFile.append(env_file); | 35 | envFile.append(env_file); |
41 | } | 36 | } |
42 | 37 | ||
43 | Settings::Settings() | 38 | Settings::Settings() |
44 | { | 39 | { |
45 | char * homeDir = getenv("HOME"); | 40 | envFile = getHomeDir(); |
46 | |||
47 | if ( homeDir) | ||
48 | { | ||
49 | envFile.append(homeDir); | ||
50 | envFile.append("/"); | 41 | envFile.append("/"); |
51 | } | ||
52 | else | ||
53 | printf( "Environment var HOME not set!\n" ); | ||
54 | 42 | ||
55 | envFile.append(DEFAULT_DIR); | 43 | envFile.append(DEFAULT_DIR); |
56 | envFile.append("/"); | 44 | envFile.append("/"); |
57 | 45 | ||
58 | envFile.append(DEFAULT_FILE); | 46 | envFile.append(DEFAULT_FILE); |
59 | } | 47 | } |
60 | 48 | ||
61 | Settings::~Settings() | 49 | Settings::~Settings() |
62 | { | 50 | { |
63 | } | 51 | } |
64 | 52 | ||
65 | bool Settings::readSetting(const string key_str,int& result) | 53 | bool Settings::readSetting(const string key_str,int& result) |
@@ -101,24 +89,36 @@ bool Settings::readSetting(const string key_str,long int& result) | |||
101 | bool Settings::readSetting(const string key_str,unsigned long& result) | 89 | bool Settings::readSetting(const string key_str,unsigned long& result) |
102 | { | 90 | { |
103 | string Buffer; | 91 | string Buffer; |
104 | if (readSetting(key_str,Buffer)) | 92 | if (readSetting(key_str,Buffer)) |
105 | { | 93 | { |
106 | result = atol(Buffer.c_str()); | 94 | result = atol(Buffer.c_str()); |
107 | return true; | 95 | return true; |
108 | } | 96 | } |
109 | else | 97 | else |
110 | return false; | 98 | return false; |
111 | } | 99 | } |
112 | 100 | ||
101 | bool Settings::readSetting(const string key_str,double& result) | ||
102 | { | ||
103 | string Buffer; | ||
104 | if (readSetting(key_str,Buffer)) | ||
105 | { | ||
106 | result = atof( Buffer.c_str() ); | ||
107 | return true; | ||
108 | } | ||
109 | else | ||
110 | return false; | ||
111 | } | ||
112 | |||
113 | bool Settings::readSetting(const string key_str,bool& result) | 113 | bool Settings::readSetting(const string key_str,bool& result) |
114 | { | 114 | { |
115 | string Buffer; | 115 | string Buffer; |
116 | if (readSetting(key_str,Buffer)) | 116 | if (readSetting(key_str,Buffer)) |
117 | { | 117 | { |
118 | result = (Buffer == "true"); | 118 | result = (Buffer == "true"); |
119 | return true; | 119 | return true; |
120 | } | 120 | } |
121 | else | 121 | else |
122 | return false; | 122 | return false; |
123 | } | 123 | } |
124 | 124 | ||
@@ -150,24 +150,32 @@ bool Settings::readSetting(const string key_str,string& results) | |||
150 | } | 150 | } |
151 | fclose(fd); | 151 | fclose(fd); |
152 | } | 152 | } |
153 | 153 | ||
154 | return(ret_flag); | 154 | return(ret_flag); |
155 | } | 155 | } |
156 | 156 | ||
157 | void Settings::writeSetting(const string key_str,const bool value) | 157 | void Settings::writeSetting(const string key_str,const bool value) |
158 | { | 158 | { |
159 | value ?writeSetting(key_str,string("true")) :writeSetting(key_str,string("false")); | 159 | value ?writeSetting(key_str,string("true")) :writeSetting(key_str,string("false")); |
160 | } | 160 | } |
161 | 161 | ||
162 | void Settings::writeSetting(const string key_str,const double value) | ||
163 | { | ||
164 | char Buffer[30]; | ||
165 | |||
166 | sprintf(Buffer,"%lf",value); | ||
167 | writeSetting(key_str,string(Buffer)); | ||
168 | } | ||
169 | |||
162 | void Settings::writeSetting(const string key_str,const int value) | 170 | void Settings::writeSetting(const string key_str,const int value) |
163 | { | 171 | { |
164 | char Buffer[30]; | 172 | char Buffer[30]; |
165 | 173 | ||
166 | sprintf(Buffer,"%i",value); | 174 | sprintf(Buffer,"%i",value); |
167 | writeSetting(key_str,string(Buffer)); | 175 | writeSetting(key_str,string(Buffer)); |
168 | } | 176 | } |
169 | 177 | ||
170 | void Settings::writeSetting(const string key_str,const unsigned int value) | 178 | void Settings::writeSetting(const string key_str,const unsigned int value) |
171 | { | 179 | { |
172 | char Buffer[30]; | 180 | char Buffer[30]; |
173 | 181 | ||
@@ -186,88 +194,78 @@ void Settings::writeSetting(const string key_str,const long int value) | |||
186 | void Settings::writeSetting(const string key_str,const unsigned long value) | 194 | void Settings::writeSetting(const string key_str,const unsigned long value) |
187 | { | 195 | { |
188 | char Buffer[30]; | 196 | char Buffer[30]; |
189 | 197 | ||
190 | sprintf(Buffer,"%lu",value); | 198 | sprintf(Buffer,"%lu",value); |
191 | writeSetting(key_str,string(Buffer)); | 199 | writeSetting(key_str,string(Buffer)); |
192 | } | 200 | } |
193 | 201 | ||
194 | void Settings::writeSetting(const string key_str,const string value) | 202 | void Settings::writeSetting(const string key_str,const string value) |
195 | { | 203 | { |
196 | // This function will write a value for the key key_str. If the key_str | 204 | // This function will write a value for the key key_str. If the key_str |
197 | // already exists then it will be overwritten. | 205 | // already exists then it will be overwritten. |
198 | |||
199 | std::vector<string> FileEntries; | ||
200 | FILE *fd=NULL,*ftemp=NULL; | 206 | FILE *fd=NULL,*ftemp=NULL; |
201 | char * dir_str; | ||
202 | char * dir_ptr; | ||
203 | char buf[MAX_LINE_SIZE]; | 207 | char buf[MAX_LINE_SIZE]; |
204 | char tempname[12]; | ||
205 | |||
206 | dir_str = strdup(envFile.c_str()); | ||
207 | printf( "dir = %s, file - %s\n", dir_str, envFile.c_str() ); | ||
208 | if (dir_str) | ||
209 | { | ||
210 | // remove file from the directory string | ||
211 | dir_ptr = strrchr(dir_str, (int)'/'); | ||
212 | if (dir_ptr) | ||
213 | { | ||
214 | *dir_ptr = 0; | ||
215 | 208 | ||
216 | // make the directory path if it does not exist | 209 | string tmp = getHomeDir() + "/tmpsfcave.dat"; |
217 | // mkdir(dir_str, 777 ); | ||
218 | 210 | ||
219 | // if file exists we need to save contents | 211 | // if file exists we need to save contents |
220 | if ((fd = fopen(envFile.c_str(), "r")) != NULL) | 212 | fd = fopen( envFile.c_str(), "r" ); |
213 | ftemp = fopen( tmp.c_str(), "w" ); | ||
214 | if ( fd != NULL && ftemp != NULL ) | ||
221 | { | 215 | { |
222 | while (fgets(buf, MAX_LINE_SIZE-1, fd)) | 216 | while (fgets(buf, MAX_LINE_SIZE-1, fd)) |
223 | FileEntries.push_back(string(buf)); | 217 | { |
218 | if ( strncmp( buf, key_str.c_str(), key_str.size() ) != 0 ) | ||
219 | fprintf( ftemp, "%s", buf ); | ||
220 | } | ||
224 | fclose(fd); | 221 | fclose(fd); |
225 | } | 222 | } |
226 | 223 | ||
227 | char *home = getenv( "HOME" ); | 224 | if ( ftemp != NULL ) |
228 | string tmp; | 225 | { |
229 | if ( home ) | 226 | fprintf(ftemp, "%s\t%s\n", key_str.c_str(),value.c_str()); |
230 | tmp = home + string( "/" ) + "tmpsfcave.dat"; | 227 | fclose( ftemp ); |
231 | else | 228 | |
232 | tmp = "./tmpsfcave.dat"; | 229 | remove(envFile.c_str()); |
230 | rename( tmp.c_str(), envFile.c_str() ); | ||
231 | } | ||
232 | /* | ||
233 | string tmp = getHomeDir() + "/tmpsfcave.dat"; | ||
233 | strcpy(tempname,tmp.c_str() ); | 234 | strcpy(tempname,tmp.c_str() ); |
234 | printf( "tmp - %s\n", tempname ); | 235 | printf( "tmp - %s\n", tempname ); |
235 | if ((ftemp = fopen(tempname,"w")) != NULL) | 236 | if ((ftemp = fopen(tempname,"w")) != NULL) |
236 | { | 237 | { |
237 | char *key1,*key2; | 238 | char *key1,*key2; |
238 | char buff1[80],buff2[80]; | 239 | char buff1[80],buff2[80]; |
239 | 240 | ||
240 | strncpy(buff1,key_str.c_str(),80); | 241 | strncpy(buff1,key_str.c_str(),80); |
241 | key1 = strtok(buff1,"\t"); | 242 | key1 = strtok(buff1,"\t"); |
242 | for (std::vector<string>::iterator iter = FileEntries.begin(); iter < FileEntries.end(); iter++) | 243 | for (std::vector<string>::iterator iter = FileEntries.begin(); iter < FileEntries.end(); iter++) |
243 | { | 244 | { |
244 | strncpy(buff2,(*iter).c_str(),80); | 245 | strncpy(buff2,(*iter).c_str(),80); |
245 | key2 = strtok(buff2,"\t"); | 246 | key2 = strtok(buff2,"\t"); |
246 | // IF not the key string then write out to file | 247 | // IF not the key string then write out to file |
247 | if (strcmp(key1,key2) != 0) | 248 | if (strcmp(key1,key2) != 0) |
248 | { | 249 | { |
249 | fprintf(ftemp,"%s",iter->c_str()); | 250 | fprintf(ftemp,"%s",iter->c_str()); |
250 | fflush(ftemp); | 251 | fflush(ftemp); |
251 | } | 252 | } |
252 | } | 253 | } |
253 | 254 | ||
254 | fprintf(ftemp, "%s\t%s\n", key_str.c_str(),value.c_str()); | 255 | fprintf(ftemp, "%s\t%s\n", key_str.c_str(),value.c_str()); |
255 | fflush(ftemp); | 256 | fflush(ftemp); |
256 | fclose(ftemp); | 257 | fclose(ftemp); |
257 | |||
258 | remove(envFile.c_str()); | ||
259 | |||
260 | rename( tempname, envFile.c_str() ); | ||
261 | } | 258 | } |
262 | else | 259 | else |
263 | printf( "Can't open file %s\n", envFile.c_str() ); | 260 | printf( "Can't open file %s\n", envFile.c_str() ); |
264 | } | 261 | } |
265 | 262 | ||
266 | delete dir_str; | 263 | delete dir_str; |
267 | } | 264 | } |
265 | */ | ||
268 | } | 266 | } |
269 | 267 | ||
270 | void Settings::deleteFile(void) | 268 | void Settings::deleteFile(void) |
271 | { | 269 | { |
272 | remove(envFile.c_str()); | 270 | remove(envFile.c_str()); |
273 | } | 271 | } |
diff --git a/noncore/games/sfcave-sdl/settings.h b/noncore/games/sfcave-sdl/settings.h index 5e828ed..a3af999 100644 --- a/noncore/games/sfcave-sdl/settings.h +++ b/noncore/games/sfcave-sdl/settings.h | |||
@@ -23,30 +23,32 @@ class Settings | |||
23 | 23 | ||
24 | public: | 24 | public: |
25 | 25 | ||
26 | Settings( char * env_file = 0, char * env_dir = 0 ); | 26 | Settings( char * env_file = 0, char * env_dir = 0 ); |
27 | Settings(); | 27 | Settings(); |
28 | ~Settings(); | 28 | ~Settings(); |
29 | 29 | ||
30 | bool readSetting(const string key_str,string& results); | 30 | bool readSetting(const string key_str,string& results); |
31 | bool readSetting(const string key_str,int& result); | 31 | bool readSetting(const string key_str,int& result); |
32 | bool readSetting(const string key_str,unsigned int& result); | 32 | bool readSetting(const string key_str,unsigned int& result); |
33 | bool readSetting(const string key_str,long int& result); | 33 | bool readSetting(const string key_str,long int& result); |
34 | bool readSetting(const string key_str,unsigned long& result); | 34 | bool readSetting(const string key_str,unsigned long& result); |
35 | bool readSetting(const string key_str,double & result); | ||
35 | bool readSetting(const string key_str,bool& result); | 36 | bool readSetting(const string key_str,bool& result); |
36 | 37 | ||
37 | void writeSetting(const string key_str,const string value); | 38 | void writeSetting(const string key_str,const string value); |
38 | void writeSetting(const string key_str,const int value); | 39 | void writeSetting(const string key_str,const int value); |
39 | void writeSetting(const string key_str,const unsigned int result); | 40 | void writeSetting(const string key_str,const unsigned int result); |
40 | void writeSetting(const string key_str,const long int result); | 41 | void writeSetting(const string key_str,const long int result); |
41 | void writeSetting(const string key_str,const unsigned long result); | 42 | void writeSetting(const string key_str,const unsigned long result); |
43 | void writeSetting(const string key_str,const double value); | ||
42 | void writeSetting(const string key_str,const bool value); | 44 | void writeSetting(const string key_str,const bool value); |
43 | 45 | ||
44 | void deleteFile(void); | 46 | void deleteFile(void); |
45 | 47 | ||
46 | private: | 48 | private: |
47 | 49 | ||
48 | string envFile; | 50 | string envFile; |
49 | }; | 51 | }; |
50 | 52 | ||
51 | 53 | ||
52 | #endif | 54 | #endif |
diff --git a/noncore/games/sfcave-sdl/sfcave.cpp b/noncore/games/sfcave-sdl/sfcave.cpp index 8d376a1..dbd788c 100644 --- a/noncore/games/sfcave-sdl/sfcave.cpp +++ b/noncore/games/sfcave-sdl/sfcave.cpp | |||
@@ -17,263 +17,261 @@ | |||
17 | #include "random.h" | 17 | #include "random.h" |
18 | #include "sfcave.h" | 18 | #include "sfcave.h" |
19 | #include "font.h" | 19 | #include "font.h" |
20 | #include "settings.h" | 20 | #include "settings.h" |
21 | #include "util.h" | 21 | #include "util.h" |
22 | 22 | ||
23 | #include "sfcave_game.h" | 23 | #include "sfcave_game.h" |
24 | #include "gates_game.h" | 24 | #include "gates_game.h" |
25 | #include "fly_game.h" | 25 | #include "fly_game.h" |
26 | 26 | ||
27 | void start( int argc, char *argv[] ) | 27 | void start( int argc, char *argv[] ) |
28 | { | 28 | { |
29 | FontHandler::init(); | 29 | SFCave *app = new SFCave( argc, argv ); |
30 | SFCave app( argc, argv ); | 30 | app->mainEventLoop(); |
31 | FontHandler::cleanUp(); | 31 | delete app; |
32 | } | 32 | } |
33 | 33 | ||
34 | #ifdef __cplusplus | 34 | #ifdef __cplusplus |
35 | extern "C" | 35 | extern "C" |
36 | #endif | 36 | #endif |
37 | int main(int argc, char *argv[]) | 37 | int main(int argc, char *argv[]) |
38 | { | 38 | { |
39 | start( argc, argv ); | 39 | start( argc, argv ); |
40 | return 0; | 40 | return 0; |
41 | } | 41 | } |
42 | 42 | ||
43 | 43 | ||
44 | SFCave :: SFCave( int argc, char *argv[] ) | 44 | SFCave :: SFCave( int argc, char *argv[] ) |
45 | { | 45 | { |
46 | setupOK = false; | ||
47 | |||
48 | // Load settings | ||
46 | string diff = loadSetting( "GameDifficulty", "Easy" ); | 49 | string diff = loadSetting( "GameDifficulty", "Easy" ); |
47 | string game = loadSetting( "GameType", "SFCave" ); | 50 | string game = loadSetting( "GameType", "SFCave" ); |
48 | musicPath = loadSetting( "MusicPath", SOUND_PATH ); | 51 | musicPath = loadSetting( "MusicPath", SOUND_PATH ); |
49 | printf( "musicPath %s\n", musicPath.c_str() ); | ||
50 | musicType = loadSetting( "MusicType", "mod,ogg" ); | 52 | musicType = loadSetting( "MusicType", "mod,ogg" ); |
53 | bool soundOn = loadBoolSetting( "SoundOn", true ); | ||
54 | bool musicOn = loadBoolSetting( "MusicOn", true ); | ||
51 | if ( musicPath[musicPath.size()-1] != '/' ) | 55 | if ( musicPath[musicPath.size()-1] != '/' ) |
52 | musicPath += "/"; | 56 | musicPath += "/"; |
57 | printf( "musicPath %s\n", musicPath.c_str() ); | ||
53 | 58 | ||
54 | // Init main SDL Library | 59 | // Init main SDL Library |
55 | initSDL( argc, argv ); | 60 | initSDL( argc, argv ); |
56 | 61 | ||
62 | // Init font handler | ||
63 | if ( !FontHandler::init() ) | ||
64 | { | ||
65 | printf( "Unable to initialise fonts!\n" ); | ||
66 | return; | ||
67 | } | ||
68 | |||
57 | // Init SoundHandler | 69 | // Init SoundHandler |
58 | if ( !SoundHandler :: init() ) | 70 | if ( !SoundHandler :: init() ) |
59 | printf("Unable to open audio!\n"); | 71 | printf("Unable to open audio!\n"); |
60 | 72 | ||
73 | SoundHandler :: setSoundsOn( soundOn ); | ||
74 | SoundHandler :: setMusicOn( musicOn ); | ||
75 | |||
61 | currentGame = Game::createGame( this, WIDTH, HEIGHT, game, diff ); | 76 | currentGame = Game::createGame( this, WIDTH, HEIGHT, game, diff ); |
62 | if ( !currentGame ) | 77 | if ( !currentGame ) |
63 | currentGame = new SFCaveGame( this, WIDTH, HEIGHT, 0 ); | 78 | currentGame = new SFCaveGame( this, WIDTH, HEIGHT, 0 ); |
64 | currentGame->setSeed(-1); | 79 | currentGame->setSeed(-1); |
80 | |||
81 | // Create menu | ||
65 | menu = new Menu( this ); | 82 | menu = new Menu( this ); |
66 | 83 | ||
84 | // Create help screen | ||
67 | help = new Help( this ); | 85 | help = new Help( this ); |
68 | 86 | ||
69 | maxFPS = 50; | 87 | maxFPS = 50; |
70 | showFps = false; | 88 | showFps = false; |
71 | mainEventLoop(); | ||
72 | 89 | ||
73 | SoundHandler :: cleanUp(); | 90 | setupOK = true; |
74 | SDL_Quit(); | ||
75 | } | 91 | } |
76 | 92 | ||
77 | SFCave :: ~SFCave() | 93 | SFCave :: ~SFCave() |
78 | { | 94 | { |
79 | if ( currentGame ) | 95 | if ( currentGame ) |
80 | delete currentGame; | 96 | delete currentGame; |
81 | 97 | ||
82 | if ( menu ) | 98 | if ( menu ) |
83 | delete menu; | 99 | delete menu; |
84 | 100 | ||
85 | SDL_FreeSurface( screen ); | 101 | if ( help ) |
86 | } | 102 | delete help; |
87 | |||
88 | 103 | ||
89 | void SFCave :: drawGameScreen( ) | 104 | SDL_FreeSurface( screen ); |
90 | { | 105 | FontHandler::cleanUp(); |
91 | //ClearScreen(screen, "Titletext"); | 106 | SoundHandler :: cleanUp(); |
92 | 107 | ||
108 | SDL_Quit(); | ||
93 | } | 109 | } |
94 | 110 | ||
111 | |||
95 | void SFCave :: initSDL( int argc, char *argv[] ) | 112 | void SFCave :: initSDL( int argc, char *argv[] ) |
96 | { | 113 | { |
97 | const SDL_VideoInfo *info; | 114 | const SDL_VideoInfo *info; |
98 | Uint8 video_bpp; | 115 | Uint8 video_bpp; |
99 | Uint32 videoflags; | 116 | Uint32 videoflags; |
100 | 117 | ||
101 | 118 | // Initialize SDL | |
102 | |||
103 | /* Initialize SDL */ | ||
104 | if ( SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0 ) { | 119 | if ( SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0 ) { |
105 | fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError()); | 120 | fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError()); |
106 | exit(1); | 121 | exit(1); |
107 | } | 122 | } |
108 | atexit(SDL_Quit); | ||
109 | 123 | ||
110 | /* Alpha blending doesn't work well at 8-bit color */ | ||
111 | video_bpp = 16; | 124 | video_bpp = 16; |
112 | 125 | ||
113 | if ( !SDL_VideoModeOK(WIDTH, HEIGHT, 16, SDL_DOUBLEBUF) ) | 126 | if ( !SDL_VideoModeOK(WIDTH, HEIGHT, video_bpp, SDL_DOUBLEBUF) ) |
114 | printf( "No double buffering\n" ); | 127 | printf( "No double buffering\n" ); |
115 | 128 | ||
116 | videoflags = SDL_HWSURFACE | SDL_SRCALPHA;//|| SDL_DOUBLEBUF;// | SDL_SRCALPHA | SDL_RESIZABLE; | 129 | videoflags = SDL_HWSURFACE | SDL_SRCALPHA; |
117 | while ( argc > 1 ) { | 130 | while ( argc > 1 ) |
131 | { | ||
118 | --argc; | 132 | --argc; |
119 | if ( strcmp(argv[argc-1], "-bpp") == 0 ) { | 133 | if ( strcmp(argv[argc-1], "-bpp") == 0 ) |
134 | { | ||
120 | video_bpp = atoi(argv[argc]); | 135 | video_bpp = atoi(argv[argc]); |
121 | --argc; | 136 | --argc; |
122 | } else | 137 | } |
123 | if ( strcmp(argv[argc], "-hw") == 0 ) { | 138 | else if ( strcmp(argv[argc], "-hw") == 0 ) |
139 | { | ||
124 | videoflags |= SDL_HWSURFACE; | 140 | videoflags |= SDL_HWSURFACE; |
125 | } else | 141 | } |
126 | if ( strcmp(argv[argc], "-warp") == 0 ) { | 142 | else if ( strcmp(argv[argc], "-warp") == 0 ) |
143 | { | ||
127 | videoflags |= SDL_HWPALETTE; | 144 | videoflags |= SDL_HWPALETTE; |
128 | } else | 145 | } |
129 | if ( strcmp(argv[argc], "-fullscreen") == 0 ) { | 146 | else if ( strcmp(argv[argc], "-fullscreen") == 0 ) |
147 | { | ||
130 | videoflags |= SDL_FULLSCREEN; | 148 | videoflags |= SDL_FULLSCREEN; |
131 | } else { | 149 | } |
150 | else if ( strcmp(argv[argc], "-h") == 0 ) | ||
151 | { | ||
132 | fprintf(stderr, | 152 | fprintf(stderr, |
133 | "Usage: %s [-bpp N] [-warp] [-hw] [-fullscreen]\n", | 153 | "Usage: %s [-bpp N] [-warp] [-hw] [-fullscreen]\n", |
134 | argv[0]); | 154 | argv[0]); |
135 | exit(1); | 155 | exit(1); |
136 | } | 156 | } |
137 | } | 157 | } |
138 | 158 | ||
139 | /* Set 240x320 video mode */ | 159 | // Set 240x320 video mode |
140 | if ( (screen=SDL_SetVideoMode(WIDTH,HEIGHT,video_bpp,videoflags)) == NULL ) { | 160 | if ( (screen = SDL_SetVideoMode( WIDTH,HEIGHT,video_bpp,videoflags )) == NULL ) |
141 | fprintf(stderr, "Couldn't set %ix%i video mode: %s\n",WIDTH,HEIGHT,SDL_GetError()); | 161 | { |
162 | printf( "Couldn't set %ix%i video mode: %s\n",WIDTH,HEIGHT,SDL_GetError() ); | ||
142 | exit(2); | 163 | exit(2); |
143 | } | 164 | } |
144 | 165 | ||
145 | /* Use alpha blending */ | 166 | // Use alpha blending |
146 | SDL_SetAlpha(screen, SDL_RLEACCEL, 0); | 167 | //SDL_SetAlpha(screen, SDL_RLEACCEL, 0); |
147 | 168 | ||
148 | /* Set title for window */ | 169 | // Set title for window |
149 | SDL_WM_SetCaption("SFCave","SFCave"); | 170 | SDL_WM_SetCaption("SFCave","SFCave"); |
150 | } | 171 | } |
151 | 172 | ||
152 | void SFCave :: mainEventLoop() | 173 | void SFCave :: mainEventLoop() |
153 | { | 174 | { |
154 | SDL_Event event; | 175 | if ( !setupOK ) |
155 | int done; | 176 | return; |
156 | 177 | ||
157 | /* Wait for a keystroke */ | 178 | // Wait for a keystroke |
158 | done = 0; | 179 | finish = false; |
159 | state = 0; | 180 | state = 0; |
160 | state = STATE_CRASHED; | 181 | state = STATE_CRASHED; |
161 | changeState( STATE_MENU ); | 182 | changeState( STATE_MENU ); |
162 | 183 | ||
163 | int FPS = 0; | 184 | FPS = 0; |
164 | bool limitFPS = true; | ||
165 | actualFPS = 0; | 185 | actualFPS = 0; |
166 | long time1 = 0; | 186 | time1 = 0; |
167 | long start; | 187 | |
168 | long end; | 188 | limitFPS = true; |
169 | //long nrTimes = 0; | 189 | while ( !finish ) |
170 | struct timeb tp; | ||
171 | while ( !done ) | ||
172 | { | 190 | { |
173 | // calc FPS | 191 | // calc FPS |
174 | ftime( &tp ); | 192 | calcFPS(); |
175 | start =(tp.time%10000)*10000 + tp.millitm; | ||
176 | // printf( "start = %ld, time1 - %d, st-tm - %d, tp.time - %ld\n", start, time1, start-time1, (tp.time%1000)*1000 ); | ||
177 | if ( start - time1 >= 1000 ) | ||
178 | { | ||
179 | actualFPS = FPS; | ||
180 | // printf( "%d FPS = %d\n", nrTimes++, actualFPS ); | ||
181 | FPS = 0; | ||
182 | time1 = start; | ||
183 | } | ||
184 | else | ||
185 | FPS ++; | ||
186 | 193 | ||
187 | SDL_FillRect( screen, 0, 0 ); | 194 | SDL_FillRect( screen, 0, 0 ); |
195 | |||
196 | handleGameState( ); | ||
197 | |||
198 | SDL_Flip( screen ); | ||
199 | |||
200 | if ( limitFPS ) | ||
201 | FPSDelay(); | ||
202 | else | ||
203 | SDL_Delay( 5 ); | ||
204 | |||
205 | handleEvents(); | ||
206 | } | ||
207 | } | ||
208 | |||
209 | |||
210 | void SFCave :: handleGameState() | ||
211 | { | ||
188 | switch( state ) | 212 | switch( state ) |
189 | { | 213 | { |
190 | case STATE_MENU: | 214 | case STATE_MENU: |
191 | SDL_FillRect( screen, 0, 0 ); | 215 | SDL_FillRect( screen, 0, 0 ); |
192 | menu->draw( screen ); | 216 | menu->draw( screen ); |
193 | break; | 217 | break; |
194 | case STATE_HELP: | 218 | case STATE_HELP: |
195 | SDL_FillRect( screen, 0, 0 ); | 219 | SDL_FillRect( screen, 0, 0 ); |
196 | help->update(); | 220 | help->update(); |
197 | help->draw( screen ); | 221 | help->draw( screen ); |
198 | break; | 222 | break; |
199 | case STATE_NEWGAME: | 223 | case STATE_NEWGAME: |
200 | printf( "STATE_NEWGAME\n" ); | ||
201 | currentGame->setReplay( false ); | 224 | currentGame->setReplay( false ); |
202 | currentGame->init(); | 225 | currentGame->init(); |
203 | changeState( STATE_PLAYING ); | 226 | changeState( STATE_PLAYING ); |
204 | break; | 227 | break; |
205 | 228 | ||
206 | case STATE_REPLAY: | 229 | case STATE_REPLAY: |
207 | printf( "STATE_NEWGAME\n" ); | ||
208 | currentGame->setReplay( true ); | 230 | currentGame->setReplay( true ); |
209 | currentGame->init(); | 231 | currentGame->init(); |
210 | changeState( STATE_PLAYING ); | 232 | changeState( STATE_PLAYING ); |
211 | break; | 233 | break; |
212 | 234 | ||
213 | case STATE_PLAYING: | 235 | case STATE_PLAYING: |
214 | case STATE_CRASHING: | 236 | case STATE_CRASHING: |
215 | currentGame->update( state ); | ||
216 | currentGame->draw( screen ); | ||
217 | break; | ||
218 | |||
219 | case STATE_CRASHED: | 237 | case STATE_CRASHED: |
220 | currentGame->update( state ); | 238 | currentGame->update( state ); |
221 | currentGame->draw( screen ); | 239 | currentGame->draw( screen ); |
222 | |||
223 | // Display Game Over message | ||
224 | break; | 240 | break; |
225 | 241 | ||
226 | case STATE_QUIT: | 242 | case STATE_QUIT: |
227 | done = 1; | 243 | finish = true; |
228 | break; | 244 | break; |
229 | } | 245 | } |
246 | } | ||
230 | 247 | ||
231 | /* Show */ | 248 | void SFCave :: handleEvents() |
232 | // if ( state != STATE_CRASHED ) | ||
233 | SDL_Flip( screen ); | ||
234 | // SDL_UpdateRect(screen, 0, 0, 0, 0); | ||
235 | |||
236 | if ( limitFPS ) | ||
237 | { | 249 | { |
238 | /* Slow down polling - limit to x FPS*/ | 250 | SDL_Event event; |
239 | ftime( &tp ); | ||
240 | end = abs((tp.time%10000)*10000 + tp.millitm); | ||
241 | if ( end-start < (1000/maxFPS) ) | ||
242 | { | ||
243 | // printf( "end - %ld, timetaken for frame = %ld, sleeping for %ld %d\n", end, end-start, (1000/maxFPS)-(end-start), actualFPS ); | ||
244 | if ( (1000/maxFPS)-(end-start) > 500 ) | ||
245 | { | ||
246 | // Should never happen but in case it does sleep for 5 seconds | ||
247 | printf( "WARNING WILL ROBINSON! delay = %ld - start %ld, end %ld\n", (1000/maxFPS)-(end-start), start, end ); | ||
248 | SDL_Delay( 5 ); | ||
249 | } | ||
250 | else | ||
251 | SDL_Delay((1000/maxFPS)-(end-start) ); | ||
252 | } | ||
253 | } | ||
254 | else | ||
255 | SDL_Delay( 5 ); | ||
256 | 251 | ||
257 | /* Check for events */ | 252 | // Check for events |
258 | while ( SDL_PollEvent(&event) ) | 253 | while ( SDL_PollEvent(&event) ) |
259 | { | 254 | { |
260 | switch (event.type) | 255 | switch (event.type) |
261 | { | 256 | { |
262 | case SDL_KEYDOWN: | 257 | case SDL_KEYDOWN: |
263 | case SDL_KEYUP: | 258 | case SDL_KEYUP: |
259 | { | ||
264 | // Escape keypress quits the app | 260 | // Escape keypress quits the app |
265 | if ( event.key.keysym.sym != SDLK_ESCAPE ) | 261 | if ( event.key.keysym.sym == SDLK_ESCAPE ) |
266 | { | 262 | { |
267 | // printf( "Key Pressed was %d %s\n", event.key.keysym.sym, SDL_GetKeyName( event.key.keysym.sym ) ); | 263 | finish = true; |
264 | break; | ||
265 | } | ||
268 | 266 | ||
269 | if ( state == STATE_MENU ) | 267 | if ( state == STATE_MENU ) |
270 | { | 268 | { |
271 | int rc = menu->handleKeys( event.key ); | 269 | int rc = menu->handleKeys( event.key ); |
272 | if ( rc != -1 ) | 270 | if ( rc != -1 ) |
273 | handleMenuSelect( rc ); | 271 | handleMenuSelect( rc ); |
274 | } | 272 | } |
275 | else if ( state == STATE_HELP ) | 273 | else if ( state == STATE_HELP ) |
276 | { | 274 | { |
277 | help->handleKeys( event.key ); | 275 | help->handleKeys( event.key ); |
278 | } | 276 | } |
279 | else if ( state == STATE_CRASHED ) | 277 | else if ( state == STATE_CRASHED ) |
@@ -295,95 +293,71 @@ void SFCave :: mainEventLoop() | |||
295 | } | 293 | } |
296 | else if ( event.key.keysym.sym == SDLK_s ) | 294 | else if ( event.key.keysym.sym == SDLK_s ) |
297 | { | 295 | { |
298 | SoundHandler :: playSound( SND_EXPLOSION ); | 296 | SoundHandler :: playSound( SND_EXPLOSION ); |
299 | } | 297 | } |
300 | } | 298 | } |
301 | } | 299 | } |
302 | else | 300 | else |
303 | { | 301 | { |
304 | switch ( event.key.keysym.sym ) | 302 | switch ( event.key.keysym.sym ) |
305 | { | 303 | { |
306 | case SDLK_f: | 304 | case SDLK_f: |
307 | printf( "showFPS - %d\n", showFps ); | ||
308 | if ( event.type == SDL_KEYDOWN ) | 305 | if ( event.type == SDL_KEYDOWN ) |
309 | showFps = !showFps; | 306 | showFps = !showFps; |
310 | break; | 307 | break; |
311 | case SDLK_l: | 308 | case SDLK_l: |
312 | if ( event.type == SDL_KEYDOWN ) | 309 | if ( event.type == SDL_KEYDOWN ) |
313 | limitFPS = !limitFPS; | 310 | limitFPS = !limitFPS; |
314 | break; | 311 | break; |
315 | 312 | ||
316 | case SDLK_p: | ||
317 | if ( event.type == SDL_KEYDOWN ) | ||
318 | { | ||
319 | maxFPS ++; | ||
320 | printf( "maxFPS - %d\n", maxFPS ); | ||
321 | } | ||
322 | break; | ||
323 | |||
324 | case SDLK_o: | ||
325 | if ( event.type == SDL_KEYDOWN ) | ||
326 | { | ||
327 | maxFPS --; | ||
328 | printf( "maxFPS - %d\n", maxFPS ); | ||
329 | } | ||
330 | break; | ||
331 | |||
332 | case SDLK_n: | ||
333 | currentGame->getTerrain()->offset++; | ||
334 | break; | ||
335 | |||
336 | default: | 313 | default: |
337 | currentGame->handleKeys( event.key ); | 314 | currentGame->handleKeys( event.key ); |
338 | break; | 315 | break; |
339 | } | 316 | } |
340 | } | 317 | } |
341 | 318 | ||
342 | break; | 319 | break; |
343 | } | 320 | } |
344 | 321 | ||
345 | |||
346 | case SDL_QUIT: | 322 | case SDL_QUIT: |
347 | done = 1; | 323 | finish = true; |
348 | break; | 324 | break; |
349 | default: | 325 | default: |
350 | break; | 326 | break; |
351 | } | 327 | } |
352 | } | 328 | } |
353 | } | 329 | } |
354 | } | ||
355 | 330 | ||
356 | void SFCave :: changeState( int s ) | 331 | void SFCave :: changeState( int s ) |
357 | { | 332 | { |
358 | if ( state != s ) | 333 | if ( state != s ) |
359 | currentGame->stateChanged( state, s ); | 334 | currentGame->stateChanged( state, s ); |
360 | 335 | ||
361 | if ( state == STATE_MENU && s == STATE_HELP ) | 336 | if ( state == STATE_MENU && s == STATE_HELP ) |
362 | help->init(); | 337 | help->init(); |
363 | if ( state == STATE_CRASHED && s == STATE_MENU ) | 338 | if ( state == STATE_CRASHED && s == STATE_MENU ) |
364 | { | 339 | { |
365 | SoundHandler :: stopMusic( true ); | 340 | SoundHandler :: stopMusic( true ); |
366 | 341 | ||
367 | string musicFile = chooseRandomFile( musicPath, musicType ); | 342 | string musicFile = chooseRandomFile( musicPath, musicType ); |
368 | printf("playing music %s\n", musicFile.c_str() ); | ||
369 | SoundHandler :: setMusicVolume( 128 ); | 343 | SoundHandler :: setMusicVolume( 128 ); |
370 | SoundHandler :: playMusic( musicFile ); | 344 | SoundHandler :: playMusic( musicFile ); |
371 | } | 345 | } |
372 | else if ( state == STATE_MENU && (s == STATE_NEWGAME || s == STATE_REPLAY) ) | 346 | else if ( state == STATE_MENU && (s == STATE_NEWGAME || s == STATE_REPLAY) ) |
373 | { | 347 | { |
374 | SoundHandler :: stopMusic( ); | 348 | SoundHandler :: stopMusic( ); |
375 | 349 | ||
376 | // Start the in game music | 350 | // Start the in game music |
377 | string musicFile = SOUND_PATH "ingame.mod"; | 351 | string musicFile = INGAME_MUSIC; |
378 | SoundHandler :: playMusic( musicFile ); | 352 | SoundHandler :: playMusic( musicFile ); |
379 | SoundHandler :: setMusicVolume( 25 ); | 353 | SoundHandler :: setMusicVolume( 25 ); |
380 | } | 354 | } |
381 | 355 | ||
382 | state = s; | 356 | state = s; |
383 | } | 357 | } |
384 | 358 | ||
385 | 359 | ||
386 | void SFCave :: handleMenuSelect( int menuId ) | 360 | void SFCave :: handleMenuSelect( int menuId ) |
387 | { | 361 | { |
388 | switch( menuId ) | 362 | switch( menuId ) |
389 | { | 363 | { |
@@ -399,47 +373,37 @@ void SFCave :: handleMenuSelect( int menuId ) | |||
399 | changeState( STATE_QUIT ); | 373 | changeState( STATE_QUIT ); |
400 | break; | 374 | break; |
401 | 375 | ||
402 | case MENU_PLAY_REPLAY: | 376 | case MENU_PLAY_REPLAY: |
403 | if ( currentGame->isReplayAvailable() ) | 377 | if ( currentGame->isReplayAvailable() ) |
404 | changeState( STATE_REPLAY ); | 378 | changeState( STATE_REPLAY ); |
405 | else | 379 | else |
406 | setMenuStatusText( "No replay available yet" ); | 380 | setMenuStatusText( "No replay available yet" ); |
407 | break; | 381 | break; |
408 | 382 | ||
409 | case MENU_LOAD_REPLAY: | 383 | case MENU_LOAD_REPLAY: |
410 | { | 384 | { |
411 | #ifdef QWS | 385 | string replayFile = getHomeDir() + "/" + currentGame->getGameName() + ".replay"; |
412 | QString replayFile = getenv( "HOME" ); | ||
413 | #else | ||
414 | QString replayFile = "."; | ||
415 | #endif | ||
416 | replayFile += string( "/" ) + currentGame->getGameName() + ".replay"; | ||
417 | 386 | ||
418 | currentGame->loadReplay( replayFile ); | 387 | currentGame->loadReplay( replayFile ); |
419 | 388 | ||
420 | break; | 389 | break; |
421 | } | 390 | } |
422 | 391 | ||
423 | case MENU_SAVE_REPLAY: | 392 | case MENU_SAVE_REPLAY: |
424 | { | 393 | { |
425 | 394 | ||
426 | if ( currentGame->isReplayAvailable() ) | 395 | if ( currentGame->isReplayAvailable() ) |
427 | { | 396 | { |
428 | #ifdef QWS | 397 | string replayFile = getHomeDir() + "/" + currentGame->getGameName() + ".replay"; |
429 | QString replayFile = getenv( "HOME" ); | ||
430 | #else | ||
431 | QString replayFile = "."; | ||
432 | #endif | ||
433 | replayFile += string( "/" ) + currentGame->getGameName() + ".replay"; | ||
434 | 398 | ||
435 | currentGame->saveReplay( replayFile ); | 399 | currentGame->saveReplay( replayFile ); |
436 | } | 400 | } |
437 | else | 401 | else |
438 | setMenuStatusText( "No replay available yet" ); | 402 | setMenuStatusText( "No replay available yet" ); |
439 | 403 | ||
440 | break; | 404 | break; |
441 | } | 405 | } |
442 | case MENU_CLEAR_SCORES: | 406 | case MENU_CLEAR_SCORES: |
443 | break; | 407 | break; |
444 | 408 | ||
445 | case MENU_GAME_SFCAVE: | 409 | case MENU_GAME_SFCAVE: |
@@ -485,38 +449,87 @@ void SFCave :: handleMenuSelect( int menuId ) | |||
485 | break; | 449 | break; |
486 | 450 | ||
487 | case MENU_DIFFICULTY_NORMAL: | 451 | case MENU_DIFFICULTY_NORMAL: |
488 | currentGame->setDifficulty( MENU_DIFFICULTY_NORMAL ); | 452 | currentGame->setDifficulty( MENU_DIFFICULTY_NORMAL ); |
489 | saveSetting( "GameDifficulty", "Medium" ); | 453 | saveSetting( "GameDifficulty", "Medium" ); |
490 | break; | 454 | break; |
491 | 455 | ||
492 | case MENU_DIFFICULTY_HARD: | 456 | case MENU_DIFFICULTY_HARD: |
493 | currentGame->setDifficulty( MENU_DIFFICULTY_HARD ); | 457 | currentGame->setDifficulty( MENU_DIFFICULTY_HARD ); |
494 | saveSetting( "GameDifficulty", "Hard" ); | 458 | saveSetting( "GameDifficulty", "Hard" ); |
495 | break; | 459 | break; |
496 | 460 | ||
461 | case MENU_DIFFICULTY_CUSTOM: | ||
462 | currentGame->setDifficulty( MENU_DIFFICULTY_CUSTOM ); | ||
463 | saveSetting( "GameDifficulty", "Custom" ); | ||
464 | break; | ||
465 | |||
497 | case MENU_SOUND_ON: | 466 | case MENU_SOUND_ON: |
498 | SoundHandler :: setSoundsOn( true ); | 467 | SoundHandler :: setSoundsOn( true ); |
468 | saveSetting( "SoundOn", "true" ); | ||
499 | break; | 469 | break; |
500 | 470 | ||
501 | case MENU_SOUND_OFF: | 471 | case MENU_SOUND_OFF: |
502 | SoundHandler :: setSoundsOn( false ); | 472 | SoundHandler :: setSoundsOn( false ); |
473 | saveSetting( "SoundOn", "false" ); | ||
503 | break; | 474 | break; |
504 | 475 | ||
505 | case MENU_MUSIC_ON: | 476 | case MENU_MUSIC_ON: |
506 | SoundHandler :: setMusicOn( true ); | 477 | SoundHandler :: setMusicOn( true ); |
478 | saveSetting( "MusicOn", "true" ); | ||
507 | break; | 479 | break; |
508 | 480 | ||
509 | case MENU_MUSIC_OFF: | 481 | case MENU_MUSIC_OFF: |
510 | SoundHandler :: setMusicOn( false ); | 482 | SoundHandler :: setMusicOn( false ); |
483 | saveSetting( "MusicOn", "false" ); | ||
484 | break; | ||
485 | |||
486 | case MENU_CUSTOM_THRUST: | ||
487 | customPlayerMenuVal = PLAYER_THRUST; | ||
488 | origValue = currentGame->getPlayer()->getValue( customPlayerMenuVal ); | ||
489 | setMenuStatusText( currentGame->getPlayer()->getValueString( customPlayerMenuVal ) ); | ||
490 | break; | ||
491 | case MENU_CUSTOM_GRAVITY: | ||
492 | customPlayerMenuVal = PLAYER_GRAVITY; | ||
493 | origValue = currentGame->getPlayer()->getValue( customPlayerMenuVal ); | ||
494 | setMenuStatusText( currentGame->getPlayer()->getValueString( customPlayerMenuVal ) ); | ||
495 | break; | ||
496 | case MENU_CUSTOM_MAXSPEEDUP: | ||
497 | customPlayerMenuVal = PLAYER_MAX_SPEED_UP; | ||
498 | origValue = currentGame->getPlayer()->getValue( customPlayerMenuVal ); | ||
499 | setMenuStatusText( currentGame->getPlayer()->getValueString( customPlayerMenuVal ) ); | ||
500 | break; | ||
501 | case MENU_CUSTOM_MAXSPEEDDOWN: | ||
502 | customPlayerMenuVal = PLAYER_MAX_SPEED_DOWN; | ||
503 | origValue = currentGame->getPlayer()->getValue( customPlayerMenuVal ); | ||
504 | setMenuStatusText( currentGame->getPlayer()->getValueString( customPlayerMenuVal ) ); | ||
505 | break; | ||
506 | case MENU_CUSTOM_INCREASE: | ||
507 | currentGame->getPlayer()->incValue( customPlayerMenuVal ); | ||
508 | setMenuStatusText( currentGame->getPlayer()->getValueString( customPlayerMenuVal ) ); | ||
509 | break; | ||
510 | case MENU_CUSTOM_DECREASE: | ||
511 | currentGame->getPlayer()->decValue( customPlayerMenuVal ); | ||
512 | setMenuStatusText( currentGame->getPlayer()->getValueString( customPlayerMenuVal ) ); | ||
513 | break; | ||
514 | case MENU_CUSTOM_SAVE: | ||
515 | { | ||
516 | // save settings | ||
517 | string key = currentGame->getGameName() + "_custom_player_" + currentGame->getPlayer()->getValueTypeString( customPlayerMenuVal ); | ||
518 | saveSetting( key, currentGame->getPlayer()->getValue( customPlayerMenuVal ) ); | ||
519 | |||
520 | break; | ||
521 | } | ||
522 | case MENU_CUSTOM_CANCEL: | ||
523 | currentGame->getPlayer()->setValue( customPlayerMenuVal, origValue ); | ||
511 | break; | 524 | break; |
512 | 525 | ||
513 | default: | 526 | default: |
514 | break; | 527 | break; |
515 | } | 528 | } |
516 | } | 529 | } |
517 | 530 | ||
518 | void SFCave :: setMenuStatusText( string statusText ) | 531 | void SFCave :: setMenuStatusText( string statusText ) |
519 | { | 532 | { |
520 | menu->setStatusText( statusText ); | 533 | menu->setStatusText( statusText ); |
521 | } | 534 | } |
522 | 535 | ||
@@ -524,23 +537,97 @@ void SFCave :: setMenuStatusText( string statusText ) | |||
524 | void SFCave :: saveSetting( string key, string val ) | 537 | void SFCave :: saveSetting( string key, string val ) |
525 | { | 538 | { |
526 | Settings cfg( "sfcave-sdl" ); | 539 | Settings cfg( "sfcave-sdl" ); |
527 | cfg.writeSetting( key, val ); | 540 | cfg.writeSetting( key, val ); |
528 | } | 541 | } |
529 | 542 | ||
530 | void SFCave :: saveSetting( string key, int val ) | 543 | void SFCave :: saveSetting( string key, int val ) |
531 | { | 544 | { |
532 | Settings cfg( "sfcave-sdl" ); | 545 | Settings cfg( "sfcave-sdl" ); |
533 | cfg.writeSetting( key, val ); | 546 | cfg.writeSetting( key, val ); |
534 | } | 547 | } |
535 | 548 | ||
549 | void SFCave :: saveSetting( string key, long val ) | ||
550 | { | ||
551 | Settings cfg( "sfcave-sdl" ); | ||
552 | cfg.writeSetting( key, val ); | ||
553 | } | ||
554 | |||
555 | void SFCave :: saveSetting( string key, double val ) | ||
556 | { | ||
557 | Settings cfg( "sfcave-sdl" ); | ||
558 | cfg.writeSetting( key, val ); | ||
559 | } | ||
560 | |||
536 | string SFCave :: loadSetting( string key, string defaultVal ) | 561 | string SFCave :: loadSetting( string key, string defaultVal ) |
537 | { | 562 | { |
538 | string val; | 563 | string val; |
539 | Settings cfg( "sfcave-sdl" ); | 564 | Settings cfg( "sfcave-sdl" ); |
540 | cfg.readSetting( key, val ); | 565 | cfg.readSetting( key, val ); |
541 | 566 | ||
542 | if ( val == "" ) | 567 | if ( val == "" ) |
543 | val = defaultVal; | 568 | val = defaultVal; |
544 | 569 | ||
545 | return val; | 570 | return val; |
546 | } | 571 | } |
572 | |||
573 | bool SFCave :: loadBoolSetting( string key, bool defaultVal ) | ||
574 | { | ||
575 | bool val = defaultVal; | ||
576 | Settings cfg( "sfcave-sdl" ); | ||
577 | cfg.readSetting( key, val ); | ||
578 | |||
579 | return val; | ||
580 | } | ||
581 | |||
582 | int SFCave :: loadIntSetting( string key, int defaultVal ) | ||
583 | { | ||
584 | int val = defaultVal; | ||
585 | Settings cfg( "sfcave-sdl" ); | ||
586 | cfg.readSetting( key, val ); | ||
587 | |||
588 | return val; | ||
589 | } | ||
590 | |||
591 | double SFCave :: loadDoubleSetting( string key, double defaultVal ) | ||
592 | { | ||
593 | double val = defaultVal; | ||
594 | Settings cfg( "sfcave-sdl" ); | ||
595 | cfg.readSetting( key, val ); | ||
596 | |||
597 | return val; | ||
598 | } | ||
599 | |||
600 | |||
601 | void SFCave :: calcFPS() | ||
602 | { | ||
603 | struct timeb tp; | ||
604 | ftime( &tp ); | ||
605 | start =(tp.time%10000)*10000 + tp.millitm; | ||
606 | if ( start - time1 >= 1000 ) | ||
607 | { | ||
608 | actualFPS = FPS; | ||
609 | FPS = 0; | ||
610 | time1 = start; | ||
611 | } | ||
612 | else | ||
613 | FPS ++; | ||
614 | } | ||
615 | |||
616 | void SFCave :: FPSDelay() | ||
617 | { | ||
618 | struct timeb tp; | ||
619 | // Slow down polling - limit to x FPS | ||
620 | ftime( &tp ); | ||
621 | end = abs((tp.time%10000)*10000 + tp.millitm); | ||
622 | if ( end-start < (1000/maxFPS) ) | ||
623 | { | ||
624 | if ( (1000/maxFPS)-(end-start) > 500 ) | ||
625 | { | ||
626 | // Should never happen but in case it does sleep for 5 seconds | ||
627 | printf( "WARNING WILL ROBINSON! delay = %ld - start %ld, end %ld\n", (1000/maxFPS)-(end-start), start, end ); | ||
628 | SDL_Delay( 5 ); | ||
629 | } | ||
630 | else | ||
631 | SDL_Delay((1000/maxFPS)-(end-start) ); | ||
632 | } | ||
633 | } | ||
diff --git a/noncore/games/sfcave-sdl/sfcave.h b/noncore/games/sfcave-sdl/sfcave.h index 96c2334..c707919 100644 --- a/noncore/games/sfcave-sdl/sfcave.h +++ b/noncore/games/sfcave-sdl/sfcave.h | |||
@@ -6,45 +6,67 @@ | |||
6 | #include "terrain.h" | 6 | #include "terrain.h" |
7 | 7 | ||
8 | class Game; | 8 | class Game; |
9 | class Menu; | 9 | class Menu; |
10 | class Help; | 10 | class Help; |
11 | 11 | ||
12 | class SFCave | 12 | class SFCave |
13 | { | 13 | { |
14 | public: | 14 | public: |
15 | SFCave( int argc, char *argv[] ); | 15 | SFCave( int argc, char *argv[] ); |
16 | ~SFCave(); | 16 | ~SFCave(); |
17 | 17 | ||
18 | void drawGameScreen(); | ||
19 | void initSDL( int argc, char *argv[] ); | 18 | void initSDL( int argc, char *argv[] ); |
20 | void mainEventLoop(); | 19 | void mainEventLoop(); |
21 | 20 | ||
22 | void setCrashed( bool val ); | 21 | void setCrashed( bool val ); |
23 | void changeState( int s ); | 22 | void changeState( int s ); |
24 | int getState() { return state; } | 23 | int getState() { return state; } |
25 | Game *getCurrentGame() { return currentGame; } | 24 | Game *getCurrentGame() { return currentGame; } |
26 | int getFPS() { return actualFPS; } | 25 | int getFPS() { return actualFPS; } |
27 | bool showFPS() { return showFps; } | 26 | bool showFPS() { return showFps; } |
28 | 27 | ||
29 | void setMenuStatusText( string statusText ); | 28 | void setMenuStatusText( string statusText ); |
30 | 29 | ||
31 | void saveSetting( string key, string val ); | 30 | void saveSetting( string key, string val ); |
32 | void saveSetting( string key, int val ); | 31 | void saveSetting( string key, int val ); |
32 | void saveSetting( string key, long val ); | ||
33 | void saveSetting( string key, double val ); | ||
33 | string loadSetting( string key, string defaultVal = "" ); | 34 | string loadSetting( string key, string defaultVal = "" ); |
35 | bool loadBoolSetting( string key, bool defaultVal); | ||
36 | int loadIntSetting( string key, int defaultVal ); | ||
37 | double loadDoubleSetting( string key, double defaultVal ); | ||
38 | |||
34 | private: | 39 | private: |
35 | SDL_Surface *screen; | 40 | SDL_Surface *screen; |
41 | bool setupOK; | ||
36 | 42 | ||
37 | Game *currentGame; | 43 | Game *currentGame; |
38 | Menu *menu; | 44 | Menu *menu; |
39 | Help *help; | 45 | Help *help; |
40 | int state; | 46 | int state; |
41 | int maxFPS; | ||
42 | int actualFPS; | ||
43 | bool showFps; | 47 | bool showFps; |
44 | string musicPath; | 48 | string musicPath; |
45 | string musicType; | 49 | string musicType; |
50 | bool finish; | ||
51 | |||
52 | bool limitFPS; | ||
53 | int maxFPS; | ||
54 | int actualFPS; | ||
55 | int FPS; | ||
56 | long time1; | ||
57 | long start; | ||
58 | long end; | ||
59 | |||
60 | // This is used when the user is setting the custom | ||
61 | // values in the menu | ||
62 | int customPlayerMenuVal; | ||
63 | double origValue; | ||
46 | 64 | ||
47 | void handleMenuSelect( int menuId ); | 65 | void handleMenuSelect( int menuId ); |
66 | void handleGameState(); | ||
67 | void handleEvents(); | ||
68 | void calcFPS(); | ||
69 | void FPSDelay(); | ||
48 | }; | 70 | }; |
49 | 71 | ||
50 | #endif | 72 | #endif |
diff --git a/noncore/games/sfcave-sdl/sfcave_game.cpp b/noncore/games/sfcave-sdl/sfcave_game.cpp index 72c5ce3..1b00e14 100644 --- a/noncore/games/sfcave-sdl/sfcave_game.cpp +++ b/noncore/games/sfcave-sdl/sfcave_game.cpp | |||
@@ -30,24 +30,37 @@ void SFCaveGame :: init() | |||
30 | 30 | ||
31 | switch( difficulty ) | 31 | switch( difficulty ) |
32 | { | 32 | { |
33 | case MENU_DIFFICULTY_EASY: | 33 | case MENU_DIFFICULTY_EASY: |
34 | blockDistance = 50; | 34 | blockDistance = 50; |
35 | break; | 35 | break; |
36 | case MENU_DIFFICULTY_NORMAL: | 36 | case MENU_DIFFICULTY_NORMAL: |
37 | blockDistance = 40; | 37 | blockDistance = 40; |
38 | break; | 38 | break; |
39 | case MENU_DIFFICULTY_HARD: | 39 | case MENU_DIFFICULTY_HARD: |
40 | blockDistance = 30; | 40 | blockDistance = 30; |
41 | break; | 41 | break; |
42 | case MENU_DIFFICULTY_CUSTOM: | ||
43 | { | ||
44 | // Read custom difficulty settings for this game | ||
45 | blockDistance = parent->loadIntSetting( "SFCave_custom_blockdistance", 50 ); | ||
46 | |||
47 | double thrust = parent->loadDoubleSetting( "SFCave_custom_player_thrust", 0.4 ); | ||
48 | double gravity = parent->loadDoubleSetting( "SFCave_custom_player_gravity", 0.6 ); | ||
49 | double maxUp = parent->loadDoubleSetting( "SFCave_custom_player_maxupspeed", 4.0 ); | ||
50 | double maxDown = parent->loadDoubleSetting( "SFCave_custom_player_maxdownspeed", 5.0 ); | ||
51 | player->setMovementInfo( thrust, gravity, maxUp, maxDown ); | ||
52 | |||
53 | break; | ||
54 | } | ||
42 | } | 55 | } |
43 | 56 | ||
44 | for ( int i = 0 ; i < BLOCKSIZE ; ++i ) | 57 | for ( int i = 0 ; i < BLOCKSIZE ; ++i ) |
45 | blocks[i].y( -1 ); | 58 | blocks[i].y( -1 ); |
46 | } | 59 | } |
47 | 60 | ||
48 | void SFCaveGame :: update( int state ) | 61 | void SFCaveGame :: update( int state ) |
49 | { | 62 | { |
50 | Game::update( state ); | 63 | Game::update( state ); |
51 | 64 | ||
52 | if ( state == STATE_PLAYING ) | 65 | if ( state == STATE_PLAYING ) |
53 | { | 66 | { |
@@ -59,25 +72,24 @@ void SFCaveGame :: update( int state ) | |||
59 | if ( terrain->getMaxHeight() < sHeight - 100 ) | 72 | if ( terrain->getMaxHeight() < sHeight - 100 ) |
60 | { | 73 | { |
61 | terrain->increaseMaxHeight( 10 ); | 74 | terrain->increaseMaxHeight( 10 ); |
62 | 75 | ||
63 | // Reduce block height | 76 | // Reduce block height |
64 | if ( terrain->getMaxHeight() > sHeight - 150 ) | 77 | if ( terrain->getMaxHeight() > sHeight - 150 ) |
65 | blockHeight -= 5; | 78 | blockHeight -= 5; |
66 | } | 79 | } |
67 | } | 80 | } |
68 | 81 | ||
69 | if ( checkCollisions() ) | 82 | if ( checkCollisions() ) |
70 | { | 83 | { |
71 | // printf( "Crashed!\n" ); | ||
72 | parent->changeState( STATE_CRASHING ); | 84 | parent->changeState( STATE_CRASHING ); |
73 | return; | 85 | return; |
74 | } | 86 | } |
75 | 87 | ||
76 | if ( nrFrames % blockDistance == 0 ) | 88 | if ( nrFrames % blockDistance == 0 ) |
77 | addBlock(); | 89 | addBlock(); |
78 | 90 | ||
79 | // Game logic goes here | 91 | // Game logic goes here |
80 | terrain->moveTerrain( 5 ); | 92 | terrain->moveTerrain( 5 ); |
81 | moveBlocks( 5 ); | 93 | moveBlocks( 5 ); |
82 | player->move( press ); | 94 | player->move( press ); |
83 | } | 95 | } |
diff --git a/noncore/games/sfcave-sdl/sound.cpp b/noncore/games/sfcave-sdl/sound.cpp index 5fda859..855f2e6 100644 --- a/noncore/games/sfcave-sdl/sound.cpp +++ b/noncore/games/sfcave-sdl/sound.cpp | |||
@@ -22,46 +22,49 @@ bool SoundHandler :: init( ) | |||
22 | { | 22 | { |
23 | printf("Unable to open audio!\n"); | 23 | printf("Unable to open audio!\n"); |
24 | return false; | 24 | return false; |
25 | } | 25 | } |
26 | 26 | ||
27 | // We're going to pre-load the sound effects that we need right here | 27 | // We're going to pre-load the sound effects that we need right here |
28 | sounds[SND_EXPLOSION] = Mix_LoadWAV( SOUND_PATH "explosion.wav"); | 28 | sounds[SND_EXPLOSION] = Mix_LoadWAV( SOUND_PATH "explosion.wav"); |
29 | sounds[SND_THRUST] = Mix_LoadWAV( SOUND_PATH "thrust.wav"); | 29 | sounds[SND_THRUST] = Mix_LoadWAV( SOUND_PATH "thrust.wav"); |
30 | 30 | ||
31 | music = 0; | 31 | music = 0; |
32 | 32 | ||
33 | soundOn = true; | 33 | soundOn = true; |
34 | musicOn = true; | ||
34 | 35 | ||
35 | return true; | 36 | return true; |
36 | } | 37 | } |
37 | 38 | ||
38 | void SoundHandler :: cleanUp() | 39 | void SoundHandler :: cleanUp() |
39 | { | 40 | { |
40 | // Free audio sounds | 41 | // Free audio sounds |
42 | if ( sounds[SND_EXPLOSION] ) | ||
41 | Mix_FreeChunk( sounds[SND_EXPLOSION] ); | 43 | Mix_FreeChunk( sounds[SND_EXPLOSION] ); |
44 | if ( sounds[SND_THRUST] ) | ||
42 | Mix_FreeChunk( sounds[SND_THRUST] ); | 45 | Mix_FreeChunk( sounds[SND_THRUST] ); |
43 | 46 | ||
44 | if ( music ) | 47 | if ( music ) |
45 | Mix_FreeMusic( music ); | 48 | Mix_FreeMusic( music ); |
46 | 49 | ||
47 | Mix_CloseAudio(); | 50 | Mix_CloseAudio(); |
48 | } | 51 | } |
49 | 52 | ||
50 | int SoundHandler :: playSound( int soundNr, int channel, int nrLoops, int playBeforeFinished ) | 53 | int SoundHandler :: playSound( int soundNr, int channel, int nrLoops, int playBeforeFinished ) |
51 | { | 54 | { |
52 | if ( !soundOn ) | 55 | if ( !soundOn ) |
53 | return -1; | 56 | return -1; |
54 | 57 | ||
55 | if ( soundNr >= NR_SOUNDS ) | 58 | if ( soundNr >= NR_SOUNDS || !sounds[soundNr] ) |
56 | return -1; | 59 | return -1; |
57 | 60 | ||
58 | Mix_Chunk *chunk = sounds[soundNr]; | 61 | Mix_Chunk *chunk = sounds[soundNr]; |
59 | if( channel == -1 || !Mix_Playing( channel ) ) | 62 | if( channel == -1 || !Mix_Playing( channel ) ) |
60 | channel = Mix_PlayChannel(-1, sounds[soundNr], nrLoops); | 63 | channel = Mix_PlayChannel(-1, sounds[soundNr], nrLoops); |
61 | 64 | ||
62 | Mix_Volume( channel, MIX_MAX_VOLUME ); | 65 | Mix_Volume( channel, MIX_MAX_VOLUME ); |
63 | return channel; | 66 | return channel; |
64 | } | 67 | } |
65 | 68 | ||
66 | void SoundHandler :: stopSound( int channel, bool fadeOut, int nrMilliSecs ) | 69 | void SoundHandler :: stopSound( int channel, bool fadeOut, int nrMilliSecs ) |
67 | { | 70 | { |
@@ -92,25 +95,25 @@ void SoundHandler :: playMusic( string musicFile ) | |||
92 | music = Mix_LoadMUS( musicFile.c_str() ); | 95 | music = Mix_LoadMUS( musicFile.c_str() ); |
93 | if(!music) | 96 | if(!music) |
94 | { | 97 | { |
95 | printf("Mix_LoadMUS(%s): %s\n", musicFile.c_str(), Mix_GetError()); | 98 | printf("Mix_LoadMUS(%s): %s\n", musicFile.c_str(), Mix_GetError()); |
96 | // this might be a critical error... | 99 | // this might be a critical error... |
97 | } | 100 | } |
98 | 101 | ||
99 | playMusic(); | 102 | playMusic(); |
100 | } | 103 | } |
101 | 104 | ||
102 | void SoundHandler :: playMusic( bool fade ) | 105 | void SoundHandler :: playMusic( bool fade ) |
103 | { | 106 | { |
104 | if ( !soundOn ) | 107 | if ( !musicOn ) |
105 | return; | 108 | return; |
106 | 109 | ||
107 | if ( music ) | 110 | if ( music ) |
108 | { | 111 | { |
109 | Mix_VolumeMusic( MIX_MAX_VOLUME ); | 112 | Mix_VolumeMusic( MIX_MAX_VOLUME ); |
110 | Mix_RewindMusic(); | 113 | Mix_RewindMusic(); |
111 | 114 | ||
112 | if ( fade ) | 115 | if ( fade ) |
113 | Mix_FadeInMusic( music, -1, 1000 ); | 116 | Mix_FadeInMusic( music, -1, 1000 ); |
114 | else | 117 | else |
115 | Mix_PlayMusic( music, -1 ); | 118 | Mix_PlayMusic( music, -1 ); |
116 | 119 | ||
diff --git a/noncore/games/sfcave-sdl/starfield.cpp b/noncore/games/sfcave-sdl/starfield.cpp index c1f2d73..82edfc1 100644 --- a/noncore/games/sfcave-sdl/starfield.cpp +++ b/noncore/games/sfcave-sdl/starfield.cpp | |||
@@ -212,12 +212,84 @@ void StarField :: draw( SDL_Surface *screen, int w, int h ) | |||
212 | 212 | ||
213 | Uint32 c = getpixel( screen, pos_x[i], pos_y[i] ); | 213 | Uint32 c = getpixel( screen, pos_x[i], pos_y[i] ); |
214 | 214 | ||
215 | 215 | ||
216 | if ( c == 0 ) | 216 | if ( c == 0 ) |
217 | lineRGBA( screen, pos_x[i], pos_y[i], pos_x [i]+ vel_x[i], pos_y[i] + vel_y[i], star_color[i], star_color[i], star_color[i], 255 ); | 217 | lineRGBA( screen, pos_x[i], pos_y[i], pos_x [i]+ vel_x[i], pos_y[i] + vel_y[i], star_color[i], star_color[i], star_color[i], 255 ); |
218 | 218 | ||
219 | //*** NOTE : if the velocity of the stars never changes then the values such as 'pos_x[i] + vel_x[i]' could be precalculated for each star *** | 219 | //*** NOTE : if the velocity of the stars never changes then the values such as 'pos_x[i] + vel_x[i]' could be precalculated for each star *** |
220 | } | 220 | } |
221 | SDL_UnlockSurface( screen ); | 221 | SDL_UnlockSurface( screen ); |
222 | } | 222 | } |
223 | } | 223 | } |
224 | |||
225 | |||
226 | |||
227 | // Test | ||
228 | #ifdef DEBUG_STARS | ||
229 | SDL_Surface *screen; | ||
230 | StarField *stars; | ||
231 | |||
232 | void go() | ||
233 | { | ||
234 | /* Initialize SDL */ | ||
235 | if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) | ||
236 | { | ||
237 | fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError()); | ||
238 | exit(1); | ||
239 | } | ||
240 | atexit(SDL_Quit); | ||
241 | |||
242 | int videoflags = SDL_SWSURFACE ; | ||
243 | |||
244 | if ( (screen=SDL_SetVideoMode(240, 320,32,videoflags)) == NULL ) | ||
245 | { | ||
246 | fprintf(stderr, "Couldn't set %ix%i video mode: %s\n",240,320,SDL_GetError()); | ||
247 | exit(2); | ||
248 | } | ||
249 | |||
250 | stars = new StarField( false, 200 ); | ||
251 | |||
252 | bool done = false; | ||
253 | while ( !done ) | ||
254 | { | ||
255 | SDL_FillRect( screen, 0, 0 ); | ||
256 | stars->draw( screen ); | ||
257 | stars->move( ); | ||
258 | |||
259 | SDL_Flip( screen ); | ||
260 | |||
261 | SDL_Delay( 10 ); | ||
262 | |||
263 | SDL_Event event; | ||
264 | while ( SDL_PollEvent(&event) ) | ||
265 | { | ||
266 | switch (event.type) | ||
267 | { | ||
268 | case SDL_KEYDOWN: | ||
269 | // Escape keypress quits the app | ||
270 | if ( event.key.keysym.sym != SDLK_ESCAPE ) | ||
271 | { | ||
272 | break; | ||
273 | } | ||
274 | case SDL_QUIT: | ||
275 | done = 1; | ||
276 | break; | ||
277 | default: | ||
278 | break; | ||
279 | } | ||
280 | } | ||
281 | } | ||
282 | } | ||
283 | |||
284 | |||
285 | |||
286 | |||
287 | #ifdef __cplusplus | ||
288 | extern "C" | ||
289 | #endif | ||
290 | int main( int argc, char *argv[] ) | ||
291 | { | ||
292 | go(); | ||
293 | } | ||
294 | |||
295 | #endif | ||
diff --git a/noncore/games/sfcave-sdl/terrain.cpp b/noncore/games/sfcave-sdl/terrain.cpp index c001a56..b243f45 100644 --- a/noncore/games/sfcave-sdl/terrain.cpp +++ b/noncore/games/sfcave-sdl/terrain.cpp | |||
@@ -38,24 +38,25 @@ void Terrain :: initTerrain() | |||
38 | { | 38 | { |
39 | dir = 1; | 39 | dir = 1; |
40 | offset = 0; | 40 | offset = 0; |
41 | 41 | ||
42 | maxHeight = 50; | 42 | maxHeight = 50; |
43 | 43 | ||
44 | mapTop[0] = (int)(nextInt(50)) + 5; | 44 | mapTop[0] = (int)(nextInt(50)) + 5; |
45 | mapBottom[0] = sHeight - (maxHeight - mapTop[0]); | 45 | mapBottom[0] = sHeight - (maxHeight - mapTop[0]); |
46 | for ( int i = 1 ; i < MAPSIZE ; ++i ) | 46 | for ( int i = 1 ; i < MAPSIZE ; ++i ) |
47 | setPoint( i ); | 47 | setPoint( i ); |
48 | 48 | ||
49 | SDL_FillRect( terrainSurface, 0, 0 ); | 49 | SDL_FillRect( terrainSurface, 0, 0 ); |
50 | |||
50 | // Draw Terrain into surface | 51 | // Draw Terrain into surface |
51 | Sint16 px[5]; | 52 | Sint16 px[5]; |
52 | Sint16 py[5]; | 53 | Sint16 py[5]; |
53 | 54 | ||
54 | for ( int i = 0 ; i < MAPSIZE ; ++i ) | 55 | for ( int i = 0 ; i < MAPSIZE ; ++i ) |
55 | { | 56 | { |
56 | int left = (i*segSize); | 57 | int left = (i*segSize); |
57 | int right = ((i+1)*segSize); | 58 | int right = ((i+1)*segSize); |
58 | px[0] = left; | 59 | px[0] = left; |
59 | py[0] = mapTop[i]; | 60 | py[0] = mapTop[i]; |
60 | px[1] = right; | 61 | px[1] = right; |
61 | py[1] = mapTop[i+1]; | 62 | py[1] = mapTop[i+1]; |
@@ -82,25 +83,24 @@ void Terrain :: initTerrain() | |||
82 | } | 83 | } |
83 | 84 | ||
84 | 85 | ||
85 | } | 86 | } |
86 | 87 | ||
87 | void Terrain :: moveTerrain( int amountToMove ) | 88 | void Terrain :: moveTerrain( int amountToMove ) |
88 | { | 89 | { |
89 | stars->move(); | 90 | stars->move(); |
90 | 91 | ||
91 | offset += amountToMove; | 92 | offset += amountToMove; |
92 | speed = offset/segSize; | 93 | speed = offset/segSize; |
93 | 94 | ||
94 | //printf( "offset - %d, speed - %d\n", offset, speed ); | ||
95 | if ( offset >= segSize ) | 95 | if ( offset >= segSize ) |
96 | { | 96 | { |
97 | for ( int i = 0 ; i < (MAPSIZE)-speed ; ++i ) | 97 | for ( int i = 0 ; i < (MAPSIZE)-speed ; ++i ) |
98 | { | 98 | { |
99 | mapTop[i] = mapTop[i+speed]; | 99 | mapTop[i] = mapTop[i+speed]; |
100 | mapBottom[i] = mapBottom[i+speed]; | 100 | mapBottom[i] = mapBottom[i+speed]; |
101 | } | 101 | } |
102 | 102 | ||
103 | for ( int i = (MAPSIZE)-speed ; i < MAPSIZE ; ++i ) | 103 | for ( int i = (MAPSIZE)-speed ; i < MAPSIZE ; ++i ) |
104 | { | 104 | { |
105 | setPoint( i ); | 105 | setPoint( i ); |
106 | } | 106 | } |
@@ -186,77 +186,61 @@ void Terrain :: increaseMaxHeight( int amount ) | |||
186 | maxHeight += amount; | 186 | maxHeight += amount; |
187 | } | 187 | } |
188 | 188 | ||
189 | void Terrain :: drawTerrain( SDL_Surface *screen ) | 189 | void Terrain :: drawTerrain( SDL_Surface *screen ) |
190 | { | 190 | { |
191 | // Blit terrain surface onto screen | 191 | // Blit terrain surface onto screen |
192 | 192 | ||
193 | SDL_Rect dst; | 193 | SDL_Rect dst; |
194 | dst.x = offset; | 194 | dst.x = offset; |
195 | dst.y = 0; | 195 | dst.y = 0; |
196 | dst.w = sWidth; | 196 | dst.w = sWidth; |
197 | dst.h = sHeight; | 197 | dst.h = sHeight; |
198 | //dst.h = maxHeight; | ||
199 | 198 | ||
200 | SDL_Rect dst2; | 199 | SDL_Rect dst2; |
201 | dst2.x = 0; | 200 | dst2.x = 0; |
202 | dst2.y = 0; | 201 | dst2.y = 0; |
203 | 202 | ||
204 | SDL_BlitSurface(terrainSurface, &dst, screen, &dst2 ); | 203 | SDL_BlitSurface(terrainSurface, &dst, screen, &dst2 ); |
205 | 204 | ||
206 | stars->draw( screen ); | 205 | stars->draw( screen ); |
207 | |||
208 | //dst.y = sHeight - maxHeight; | ||
209 | //dst2.y = sHeight - maxHeight; | ||
210 | //SDL_BlitSurface(terrainSurface, &dst, screen, &dst2 ); | ||
211 | |||
212 | /* | ||
213 | for ( int i = 0 ; i < MAPSIZE ; ++i ) | ||
214 | { | ||
215 | int x1 = (i*segSize) - (offset*speed); | ||
216 | int x2 = ((i+1)*segSize)-(offset*speed); | ||
217 | if ( x2 >= sWidth ) | ||
218 | x2 = sWidth-1; | ||
219 | aalineRGBA( screen, x1, mapTop[i], x2, mapTop[i+1], 0, 220, 0, 255 ); | ||
220 | aalineRGBA( screen, x1, mapBottom[i], x2, mapBottom[i+1], 0, 220, 0, 255 ); | ||
221 | } | ||
222 | */ | ||
223 | } | 206 | } |
224 | 207 | ||
225 | bool Terrain :: checkCollision( int x, int y, int h ) | 208 | bool Terrain :: checkCollision( int x, int y, int h ) |
226 | { | 209 | { |
227 | if ( y < 0 || y > sHeight ) | 210 | if ( y < 0 || y > sHeight ) |
228 | return true; | 211 | return true; |
212 | |||
229 | // First get segment that matches x | 213 | // First get segment that matches x |
230 | SDL_LockSurface( terrainSurface ); | 214 | SDL_LockSurface( terrainSurface ); |
231 | 215 | ||
232 | Uint32 c = getpixel( terrainSurface, x, y ); | 216 | Uint32 c = getpixel( terrainSurface, x, y ); |
233 | 217 | ||
234 | SDL_UnlockSurface( terrainSurface ); | 218 | SDL_UnlockSurface( terrainSurface ); |
235 | 219 | ||
236 | if ( c == 0 ) | 220 | if ( c == 0 ) |
237 | return false; | 221 | return false; |
238 | else | 222 | else |
239 | return true; | 223 | return true; |
240 | } | 224 | } |
241 | 225 | ||
242 | 226 | ||
243 | // Test | 227 | // Test |
244 | #ifdef DEBUG_TERRAIN | 228 | #ifdef DEBUG_TERRAIN |
245 | SDL_Surface *screen; | 229 | SDL_Surface *screen; |
246 | Terrain *terrain; | 230 | Terrain *terrain; |
247 | 231 | ||
248 | void go() | 232 | void go() |
249 | { | 233 | { |
250 | /* Initialize SDL */ | 234 | // Initialize SDL |
251 | if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) | 235 | if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) |
252 | { | 236 | { |
253 | fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError()); | 237 | fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError()); |
254 | exit(1); | 238 | exit(1); |
255 | } | 239 | } |
256 | atexit(SDL_Quit); | 240 | atexit(SDL_Quit); |
257 | 241 | ||
258 | int videoflags = SDL_SWSURFACE ; | 242 | int videoflags = SDL_SWSURFACE ; |
259 | 243 | ||
260 | if ( (screen=SDL_SetVideoMode(280, 320,32,videoflags)) == NULL ) | 244 | if ( (screen=SDL_SetVideoMode(280, 320,32,videoflags)) == NULL ) |
261 | { | 245 | { |
262 | fprintf(stderr, "Couldn't set %ix%i video mode: %s\n",WIDTH,HEIGHT,SDL_GetError()); | 246 | fprintf(stderr, "Couldn't set %ix%i video mode: %s\n",WIDTH,HEIGHT,SDL_GetError()); |
diff --git a/noncore/games/sfcave-sdl/util.cpp b/noncore/games/sfcave-sdl/util.cpp index 86738ad..f73e256 100644 --- a/noncore/games/sfcave-sdl/util.cpp +++ b/noncore/games/sfcave-sdl/util.cpp | |||
@@ -26,39 +26,50 @@ Uint32 getpixel(SDL_Surface *surface, int x, int y) | |||
26 | return p[0] << 16 | p[1] << 8 | p[2]; | 26 | return p[0] << 16 | p[1] << 8 | p[2]; |
27 | else | 27 | else |
28 | return p[0] | p[1] << 8 | p[2] << 16; | 28 | return p[0] | p[1] << 8 | p[2] << 16; |
29 | 29 | ||
30 | case 4: | 30 | case 4: |
31 | return *(Uint32 *)p; | 31 | return *(Uint32 *)p; |
32 | 32 | ||
33 | default: | 33 | default: |
34 | return 0; /* shouldn't happen, but avoids warnings */ | 34 | return 0; /* shouldn't happen, but avoids warnings */ |
35 | } | 35 | } |
36 | } | 36 | } |
37 | 37 | ||
38 | const char *chooseRandomFile( string path, string fileType ) | 38 | string chooseRandomFile( string path, string fileType ) |
39 | { | 39 | { |
40 | vector<string> files; | 40 | vector<string> files; |
41 | DIR *d = opendir( path.c_str() ); | 41 | DIR *d = opendir( path.c_str() ); |
42 | if ( !d ) | 42 | if ( !d ) |
43 | return ""; | 43 | return ""; |
44 | 44 | ||
45 | struct dirent *item = readdir( d ); | 45 | struct dirent *item = readdir( d ); |
46 | while ( item ) | 46 | while ( item ) |
47 | { | 47 | { |
48 | string file = string( path ) + item->d_name; | 48 | string file = string( path ) + item->d_name; |
49 | 49 | ||
50 | // Rip extension from file | 50 | // Rip extension from file |
51 | int pos = file.find( ".", 1 ) + 1; | 51 | int pos = file.find( ".", 1 ) + 1; |
52 | string tmp = file.substr( pos ); | 52 | string tmp = file.substr( pos ); |
53 | printf( "pos = %d, tmp =%s\n", pos, tmp.c_str() ); | ||
54 | if ( tmp.size() > 0 && fileType.find( tmp ) != -1 ) | 53 | if ( tmp.size() > 0 && fileType.find( tmp ) != -1 ) |
55 | { | 54 | { |
56 | printf( "Matching <%s> - %s with <%s>\n", file.substr( pos ).c_str(), file.c_str(), fileType.c_str() ); | ||
57 | files.push_back( file ); | 55 | files.push_back( file ); |
58 | } | 56 | } |
59 | item = readdir( d ); | 57 | item = readdir( d ); |
60 | } | 58 | } |
61 | 59 | ||
62 | closedir( d ); | 60 | closedir( d ); |
63 | return files[nextInt( files.size() )].c_str(); | 61 | return files[nextInt( files.size() )]; |
62 | } | ||
63 | |||
64 | |||
65 | string getHomeDir() | ||
66 | { | ||
67 | string home; | ||
68 | #ifdef QWS | ||
69 | home = getenv( "HOME" ); | ||
70 | #else | ||
71 | home = "."; | ||
72 | #endif | ||
73 | |||
74 | return home; | ||
64 | } | 75 | } |
diff --git a/noncore/games/sfcave-sdl/util.h b/noncore/games/sfcave-sdl/util.h index fe3e9c0..e3aa31a 100644 --- a/noncore/games/sfcave-sdl/util.h +++ b/noncore/games/sfcave-sdl/util.h | |||
@@ -1,10 +1,10 @@ | |||
1 | #ifndef __UTIL_H | 1 | #ifndef __UTIL_H |
2 | #define __UTIL_H | 2 | #define __UTIL_H |
3 | 3 | ||
4 | #include <string> | 4 | #include <string> |
5 | using namespace std; | 5 | using namespace std; |
6 | 6 | ||
7 | Uint32 getpixel(SDL_Surface *surface, int x, int y); | 7 | Uint32 getpixel(SDL_Surface *surface, int x, int y); |
8 | const char *chooseRandomFile( string path, string fileType ); | 8 | string chooseRandomFile( string path, string fileType ); |
9 | 9 | string getHomeDir(); | |
10 | #endif | 10 | #endif |