diff options
author | Starla Insigna <starla4444@gmail.com> | 2013-08-27 11:39:37 -0400 |
---|---|---|
committer | Starla Insigna <starla4444@gmail.com> | 2013-08-27 11:39:37 -0400 |
commit | ffd335aca284c286030e2b26f1a02a0441748f46 (patch) | |
tree | bcc1c241621fe159ae7ef178122fb41c5f23eb00 | |
parent | d47da18958b5214def5127e201f60668c566d9bb (diff) | |
download | mazeoflife-ffd335aca284c286030e2b26f1a02a0441748f46.tar.gz mazeoflife-ffd335aca284c286030e2b26f1a02a0441748f46.tar.bz2 mazeoflife-ffd335aca284c286030e2b26f1a02a0441748f46.zip |
Started rewriting game from scratch with SDL2
Only the title screen is currently implemented
-rw-r--r-- | .hgignore | 1 | ||||
-rw-r--r-- | Makefile.am | 2 | ||||
-rw-r--r-- | acinclude.m4 | 129 | ||||
-rw-r--r-- | chlstate.cpp | 50 | ||||
-rw-r--r-- | chlstate.h | 16 | ||||
-rw-r--r-- | configure.ac | 42 | ||||
-rw-r--r-- | gamestate.cpp | 317 | ||||
-rw-r--r-- | gamestate.h | 59 | ||||
-rw-r--r-- | highscore.cpp | 2 | ||||
-rw-r--r-- | hsglobal.cpp | 63 | ||||
-rw-r--r-- | hsglobal.h | 18 | ||||
-rw-r--r-- | hslist.cpp | 15 | ||||
-rw-r--r-- | hslist.h | 4 | ||||
-rw-r--r-- | hslocal.cpp | 82 | ||||
-rw-r--r-- | hslocal.h | 18 | ||||
-rw-r--r-- | hsnew.cpp | 220 | ||||
-rw-r--r-- | hsnew.h | 35 | ||||
-rw-r--r-- | hssubmit.cpp | 226 | ||||
-rw-r--r-- | hssubmit.h | 34 | ||||
-rw-r--r-- | htpstate.cpp | 57 | ||||
-rw-r--r-- | htpstate.h | 18 | ||||
-rw-r--r-- | icon.ico | bin | 6766 -> 0 bytes | |||
-rw-r--r-- | includes.h | 23 | ||||
-rw-r--r-- | mazeoflife.cpp | 141 | ||||
-rw-r--r-- | mazeoflife.h | 8 | ||||
-rw-r--r-- | state.h | 8 | ||||
-rw-r--r-- | titlestate.cpp | 84 | ||||
-rw-r--r-- | titlestate.h | 14 | ||||
-rw-r--r-- | util.cpp | 69 | ||||
-rw-r--r-- | util.h | 14 | ||||
-rw-r--r-- | winres.rc | 1 |
31 files changed, 270 insertions, 1500 deletions
diff --git a/.hgignore b/.hgignore index 85018a3..45a2263 100644 --- a/.hgignore +++ b/.hgignore | |||
@@ -11,3 +11,4 @@ missing | |||
11 | install-sh | 11 | install-sh |
12 | depcomp | 12 | depcomp |
13 | mazeoflife | 13 | mazeoflife |
14 | Makefile | ||
diff --git a/Makefile.am b/Makefile.am index f1b00a1..803036c 100644 --- a/Makefile.am +++ b/Makefile.am | |||
@@ -2,6 +2,6 @@ AUTOMAKE_OPTIONS = subdir-objects | |||
2 | ACLOCAL_AMFLAGS = ${ACLOCAL_FLAGS} | 2 | ACLOCAL_AMFLAGS = ${ACLOCAL_FLAGS} |
3 | 3 | ||
4 | bin_PROGRAMS = mazeoflife | 4 | bin_PROGRAMS = mazeoflife |
5 | mazeoflife_SOURCES = chlstate.cpp gamestate.cpp highscore.cpp hsglobal.cpp hslist.cpp hslocal.cpp hsnew.cpp hssubmit.cpp htpstate.cpp mazeoflife.cpp titlestate.cpp | 5 | mazeoflife_SOURCES = highscore.cpp hslist.cpp mazeoflife.cpp util.cpp titlestate.cpp |
6 | AM_CXXFLAGS = $(SDLTTF_CXXFLAGS) $(SDLNET_CXXFLAGS) | 6 | AM_CXXFLAGS = $(SDLTTF_CXXFLAGS) $(SDLNET_CXXFLAGS) |
7 | mazeoflife_LDADD = $(SDLTTF_LIBS) $(SDLNET_LIBS) | 7 | mazeoflife_LDADD = $(SDLTTF_LIBS) $(SDLNET_LIBS) |
diff --git a/acinclude.m4 b/acinclude.m4 index 0d44c45..a03b2d2 100644 --- a/acinclude.m4 +++ b/acinclude.m4 | |||
@@ -7,12 +7,12 @@ | |||
7 | 7 | ||
8 | # serial 1 | 8 | # serial 1 |
9 | 9 | ||
10 | dnl AM_PATH_SDL([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]]) | 10 | dnl AM_PATH_SDL2([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]]) |
11 | dnl Test for SDL, and define SDL_CFLAGS and SDL_LIBS | 11 | dnl Test for SDL, and define SDL_CFLAGS and SDL_LIBS |
12 | dnl | 12 | dnl |
13 | AC_DEFUN([AM_PATH_SDL], | 13 | AC_DEFUN([AM_PATH_SDL2], |
14 | [dnl | 14 | [dnl |
15 | dnl Get the cflags and libraries from the sdl-config script | 15 | dnl Get the cflags and libraries from the sdl2-config script |
16 | dnl | 16 | dnl |
17 | AC_ARG_WITH(sdl-prefix,[ --with-sdl-prefix=PFX Prefix where SDL is installed (optional)], | 17 | AC_ARG_WITH(sdl-prefix,[ --with-sdl-prefix=PFX Prefix where SDL is installed (optional)], |
18 | sdl_prefix="$withval", sdl_prefix="") | 18 | sdl_prefix="$withval", sdl_prefix="") |
@@ -21,50 +21,63 @@ AC_ARG_WITH(sdl-exec-prefix,[ --with-sdl-exec-prefix=PFX Exec prefix where SDL | |||
21 | AC_ARG_ENABLE(sdltest, [ --disable-sdltest Do not try to compile and run a test SDL program], | 21 | AC_ARG_ENABLE(sdltest, [ --disable-sdltest Do not try to compile and run a test SDL program], |
22 | , enable_sdltest=yes) | 22 | , enable_sdltest=yes) |
23 | 23 | ||
24 | if test x$sdl_exec_prefix != x ; then | 24 | min_sdl_version=ifelse([$1], ,2.0.0,$1) |
25 | sdl_config_args="$sdl_config_args --exec-prefix=$sdl_exec_prefix" | 25 | |
26 | if test x${SDL_CONFIG+set} != xset ; then | 26 | if test "x$sdl_prefix$sdl_exec_prefix" = x ; then |
27 | SDL_CONFIG=$sdl_exec_prefix/bin/sdl-config | 27 | PKG_CHECK_MODULES([SDL], [sdl2 >= $min_sdl_version], |
28 | [sdl_pc=yes], | ||
29 | [sdl_pc=no]) | ||
30 | else | ||
31 | sdl_pc=no | ||
32 | if test x$sdl_exec_prefix != x ; then | ||
33 | sdl_config_args="$sdl_config_args --exec-prefix=$sdl_exec_prefix" | ||
34 | if test x${SDL2_CONFIG+set} != xset ; then | ||
35 | SDL2_CONFIG=$sdl_exec_prefix/bin/sdl2-config | ||
36 | fi | ||
28 | fi | 37 | fi |
29 | fi | 38 | if test x$sdl_prefix != x ; then |
30 | if test x$sdl_prefix != x ; then | 39 | sdl_config_args="$sdl_config_args --prefix=$sdl_prefix" |
31 | sdl_config_args="$sdl_config_args --prefix=$sdl_prefix" | 40 | if test x${SDL2_CONFIG+set} != xset ; then |
32 | if test x${SDL_CONFIG+set} != xset ; then | 41 | SDL2_CONFIG=$sdl_prefix/bin/sdl2-config |
33 | SDL_CONFIG=$sdl_prefix/bin/sdl-config | 42 | fi |
34 | fi | 43 | fi |
35 | fi | 44 | fi |
36 | 45 | ||
37 | as_save_PATH="$PATH" | 46 | if test "x$sdl_pc" = xyes ; then |
38 | if test "x$prefix" != xNONE; then | 47 | no_sdl="" |
39 | PATH="$prefix/bin:$prefix/usr/bin:$PATH" | 48 | SDL2_CONFIG="pkg-config sdl2" |
40 | fi | ||
41 | AC_PATH_PROG(SDL_CONFIG, sdl-config, no, [$PATH]) | ||
42 | PATH="$as_save_PATH" | ||
43 | min_sdl_version=ifelse([$1], ,0.11.0,$1) | ||
44 | AC_MSG_CHECKING(for SDL - version >= $min_sdl_version) | ||
45 | no_sdl="" | ||
46 | if test "$SDL_CONFIG" = "no" ; then | ||
47 | no_sdl=yes | ||
48 | else | 49 | else |
49 | SDL_CFLAGS=`$SDL_CONFIG $sdl_config_args --cflags` | 50 | as_save_PATH="$PATH" |
50 | SDL_LIBS=`$SDL_CONFIG $sdl_config_args --libs` | 51 | if test "x$prefix" != xNONE && test "$cross_compiling" != yes; then |
52 | PATH="$prefix/bin:$prefix/usr/bin:$PATH" | ||
53 | fi | ||
54 | AC_PATH_PROG(SDL2_CONFIG, sdl2-config, no, [$PATH]) | ||
55 | PATH="$as_save_PATH" | ||
56 | AC_MSG_CHECKING(for SDL - version >= $min_sdl_version) | ||
57 | no_sdl="" | ||
51 | 58 | ||
52 | sdl_major_version=`$SDL_CONFIG $sdl_config_args --version | \ | 59 | if test "$SDL2_CONFIG" = "no" ; then |
53 | sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'` | 60 | no_sdl=yes |
54 | sdl_minor_version=`$SDL_CONFIG $sdl_config_args --version | \ | 61 | else |
55 | sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'` | 62 | SDL_CFLAGS=`$SDL2_CONFIG $sdl_config_args --cflags` |
56 | sdl_micro_version=`$SDL_CONFIG $sdl_config_args --version | \ | 63 | SDL_LIBS=`$SDL2_CONFIG $sdl_config_args --libs` |
57 | sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'` | 64 | |
58 | if test "x$enable_sdltest" = "xyes" ; then | 65 | sdl_major_version=`$SDL2_CONFIG $sdl_config_args --version | \ |
59 | ac_save_CFLAGS="$CFLAGS" | 66 | sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'` |
60 | ac_save_CXXFLAGS="$CXXFLAGS" | 67 | sdl_minor_version=`$SDL2_CONFIG $sdl_config_args --version | \ |
61 | ac_save_LIBS="$LIBS" | 68 | sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'` |
62 | CFLAGS="$CFLAGS $SDL_CFLAGS" | 69 | sdl_micro_version=`$SDL2_CONFIG $sdl_config_args --version | \ |
63 | CXXFLAGS="$CXXFLAGS $SDL_CFLAGS" | 70 | sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'` |
64 | LIBS="$LIBS $SDL_LIBS" | 71 | if test "x$enable_sdltest" = "xyes" ; then |
72 | ac_save_CFLAGS="$CFLAGS" | ||
73 | ac_save_CXXFLAGS="$CXXFLAGS" | ||
74 | ac_save_LIBS="$LIBS" | ||
75 | CFLAGS="$CFLAGS $SDL_CFLAGS" | ||
76 | CXXFLAGS="$CXXFLAGS $SDL_CFLAGS" | ||
77 | LIBS="$LIBS $SDL_LIBS" | ||
65 | dnl | 78 | dnl |
66 | dnl Now check if the installed SDL is sufficiently new. (Also sanity | 79 | dnl Now check if the installed SDL is sufficiently new. (Also sanity |
67 | dnl checks the results of sdl-config to some extent | 80 | dnl checks the results of sdl2-config to some extent |
68 | dnl | 81 | dnl |
69 | rm -f conf.sdltest | 82 | rm -f conf.sdltest |
70 | AC_TRY_RUN([ | 83 | AC_TRY_RUN([ |
@@ -114,32 +127,36 @@ int main (int argc, char *argv[]) | |||
114 | } | 127 | } |
115 | else | 128 | else |
116 | { | 129 | { |
117 | printf("\n*** 'sdl-config --version' returned %d.%d.%d, but the minimum version\n", $sdl_major_version, $sdl_minor_version, $sdl_micro_version); | 130 | printf("\n*** 'sdl2-config --version' returned %d.%d.%d, but the minimum version\n", $sdl_major_version, $sdl_minor_version, $sdl_micro_version); |
118 | printf("*** of SDL required is %d.%d.%d. If sdl-config is correct, then it is\n", major, minor, micro); | 131 | printf("*** of SDL required is %d.%d.%d. If sdl2-config is correct, then it is\n", major, minor, micro); |
119 | printf("*** best to upgrade to the required version.\n"); | 132 | printf("*** best to upgrade to the required version.\n"); |
120 | printf("*** If sdl-config was wrong, set the environment variable SDL_CONFIG\n"); | 133 | printf("*** If sdl2-config was wrong, set the environment variable SDL2_CONFIG\n"); |
121 | printf("*** to point to the correct copy of sdl-config, and remove the file\n"); | 134 | printf("*** to point to the correct copy of sdl2-config, and remove the file\n"); |
122 | printf("*** config.cache before re-running configure\n"); | 135 | printf("*** config.cache before re-running configure\n"); |
123 | return 1; | 136 | return 1; |
124 | } | 137 | } |
125 | } | 138 | } |
126 | 139 | ||
127 | ],, no_sdl=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"]) | 140 | ],, no_sdl=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"]) |
128 | CFLAGS="$ac_save_CFLAGS" | 141 | CFLAGS="$ac_save_CFLAGS" |
129 | CXXFLAGS="$ac_save_CXXFLAGS" | 142 | CXXFLAGS="$ac_save_CXXFLAGS" |
130 | LIBS="$ac_save_LIBS" | 143 | LIBS="$ac_save_LIBS" |
131 | fi | 144 | fi |
145 | fi | ||
146 | if test "x$no_sdl" = x ; then | ||
147 | AC_MSG_RESULT(yes) | ||
148 | else | ||
149 | AC_MSG_RESULT(no) | ||
150 | fi | ||
132 | fi | 151 | fi |
133 | if test "x$no_sdl" = x ; then | 152 | if test "x$no_sdl" = x ; then |
134 | AC_MSG_RESULT(yes) | 153 | ifelse([$2], , :, [$2]) |
135 | ifelse([$2], , :, [$2]) | ||
136 | else | 154 | else |
137 | AC_MSG_RESULT(no) | 155 | if test "$SDL2_CONFIG" = "no" ; then |
138 | if test "$SDL_CONFIG" = "no" ; then | 156 | echo "*** The sdl2-config script installed by SDL could not be found" |
139 | echo "*** The sdl-config script installed by SDL could not be found" | ||
140 | echo "*** If SDL was installed in PREFIX, make sure PREFIX/bin is in" | 157 | echo "*** If SDL was installed in PREFIX, make sure PREFIX/bin is in" |
141 | echo "*** your path, or set the SDL_CONFIG environment variable to the" | 158 | echo "*** your path, or set the SDL2_CONFIG environment variable to the" |
142 | echo "*** full path to sdl-config." | 159 | echo "*** full path to sdl2-config." |
143 | else | 160 | else |
144 | if test -f conf.sdltest ; then | 161 | if test -f conf.sdltest ; then |
145 | : | 162 | : |
@@ -169,7 +186,7 @@ int main(int argc, char *argv[]) | |||
169 | [ echo "*** The test program failed to compile or link. See the file config.log for the" | 186 | [ echo "*** The test program failed to compile or link. See the file config.log for the" |
170 | echo "*** exact error that occured. This usually means SDL was incorrectly installed" | 187 | echo "*** exact error that occured. This usually means SDL was incorrectly installed" |
171 | echo "*** or that you have moved SDL since it was installed. In the latter case, you" | 188 | echo "*** or that you have moved SDL since it was installed. In the latter case, you" |
172 | echo "*** may want to edit the sdl-config script: $SDL_CONFIG" ]) | 189 | echo "*** may want to edit the sdl2-config script: $SDL2_CONFIG" ]) |
173 | CFLAGS="$ac_save_CFLAGS" | 190 | CFLAGS="$ac_save_CFLAGS" |
174 | CXXFLAGS="$ac_save_CXXFLAGS" | 191 | CXXFLAGS="$ac_save_CXXFLAGS" |
175 | LIBS="$ac_save_LIBS" | 192 | LIBS="$ac_save_LIBS" |
@@ -182,4 +199,4 @@ int main(int argc, char *argv[]) | |||
182 | AC_SUBST(SDL_CFLAGS) | 199 | AC_SUBST(SDL_CFLAGS) |
183 | AC_SUBST(SDL_LIBS) | 200 | AC_SUBST(SDL_LIBS) |
184 | rm -f conf.sdltest | 201 | rm -f conf.sdltest |
185 | ]) \ No newline at end of file | 202 | ]) |
diff --git a/chlstate.cpp b/chlstate.cpp deleted file mode 100644 index 5c9f488..0000000 --- a/chlstate.cpp +++ /dev/null | |||
@@ -1,50 +0,0 @@ | |||
1 | #include "includes.h" | ||
2 | |||
3 | ChooseHighscoreListState::ChooseHighscoreListState() | ||
4 | { | ||
5 | background = SDL_LoadBMP("resources/chl.bmp"); | ||
6 | pointer = SDL_LoadBMP("resources/pointer.bmp"); | ||
7 | |||
8 | selection = 0; | ||
9 | } | ||
10 | |||
11 | void ChooseHighscoreListState::input(SDL_keysym key) | ||
12 | { | ||
13 | if ((key.sym == SDLK_UP) && (selection != 0)) | ||
14 | { | ||
15 | selection--; | ||
16 | } else if ((key.sym == SDLK_DOWN) && (selection != 2)) | ||
17 | { | ||
18 | selection++; | ||
19 | } else if (key.sym == SDLK_RETURN) | ||
20 | { | ||
21 | switch (selection) | ||
22 | { | ||
23 | case 0: | ||
24 | changeState(new LocalHighscoreListState(false)); | ||
25 | |||
26 | break; | ||
27 | case 1: | ||
28 | changeState(new GlobalHighscoreListState()); | ||
29 | |||
30 | break; | ||
31 | case 2: | ||
32 | changeState(new TitleState()); | ||
33 | |||
34 | break; | ||
35 | } | ||
36 | } | ||
37 | } | ||
38 | |||
39 | void ChooseHighscoreListState::render(SDL_Surface* screen) | ||
40 | { | ||
41 | SDL_BlitSurface(background, NULL, screen, NULL); | ||
42 | |||
43 | SDL_Rect pSpace; | ||
44 | pSpace.x = 127; | ||
45 | pSpace.y = (selection==0?306:(selection==1?336:396)); | ||
46 | pSpace.w = pointer->w; | ||
47 | pSpace.h = pointer->h; | ||
48 | |||
49 | SDL_BlitSurface(pointer, NULL, screen, &pSpace); | ||
50 | } | ||
diff --git a/chlstate.h b/chlstate.h deleted file mode 100644 index 15f1d05..0000000 --- a/chlstate.h +++ /dev/null | |||
@@ -1,16 +0,0 @@ | |||
1 | #ifndef CHLSTATE_H | ||
2 | #define CHLSTATE_H | ||
3 | |||
4 | class ChooseHighscoreListState : public State { | ||
5 | public: | ||
6 | ChooseHighscoreListState(); | ||
7 | void input(SDL_keysym key); | ||
8 | void render(SDL_Surface* screen); | ||
9 | |||
10 | private: | ||
11 | SDL_Surface* background; | ||
12 | SDL_Surface* pointer; | ||
13 | int selection; | ||
14 | }; | ||
15 | |||
16 | #endif | ||
diff --git a/configure.ac b/configure.ac index f311aa6..4206e6b 100644 --- a/configure.ac +++ b/configure.ac | |||
@@ -1,44 +1,44 @@ | |||
1 | AC_INIT(mazeoflife, version-2.0) | 1 | AC_INIT(mazeoflife, version-3.0) |
2 | AC_PREREQ([2.59]) | 2 | AC_PREREQ([2.59]) |
3 | AM_INIT_AUTOMAKE([1.10 no-define foreign]) | 3 | AM_INIT_AUTOMAKE([1.10 no-define foreign]) |
4 | AC_PROG_CXX | 4 | AC_PROG_CXX |
5 | AC_CONFIG_FILES([Makefile]) | 5 | AC_CONFIG_FILES([Makefile]) |
6 | 6 | ||
7 | dnl Check for SDL | 7 | dnl Check for SDL |
8 | SDL_VERSION=1.2.0 | 8 | SDL_VERSION=2.0.0 |
9 | AM_PATH_SDL($SDL_VERSION, | 9 | AM_PATH_SDL2($SDL_VERSION, |
10 | :, | 10 | :, |
11 | AC_MSG_ERROR([*** SDL version $SDL_VERSION not found!]) | 11 | AC_MSG_ERROR([*** SDL version $SDL_VERSION not found!]) |
12 | ) | 12 | ) |
13 | CXXFLAGS="$CXXFLAGS $SDL_CFLAGS" | 13 | CXXFLAGS="$CXXFLAGS $SDL_CFLAGS" |
14 | LIBS="$LIBS $SDL_LIBS" | 14 | LIBS="$LIBS $SDL_LIBS" |
15 | 15 | ||
16 | dnl Check for SDL_ttf | 16 | dnl Check for SDL2_ttf |
17 | AC_ARG_WITH([sdl-ttf-include-path], | 17 | AC_ARG_WITH([sdl-ttf2-include-path], |
18 | [AS_HELP_STRING([--with-sdl-ttf-include-path], | 18 | [AS_HELP_STRING([--with-sdl2-ttf-include-path], |
19 | [location of the SDL_ttf headers, defaults to /usr/include/SDL])], | 19 | [location of the SDL2_ttf headers, defaults to /usr/include/SDL2])], |
20 | [SDLTTF_CXXFLAGS="-I$withval"], | 20 | [SDLTTF_CXXFLAGS="-I$withval"], |
21 | [SDLTTF_CXXFLAGS="-I/usr/include/SDL"]) | 21 | [SDLTTF_CXXFLAGS="-I/usr/include/SDL2"]) |
22 | AC_SUBST([SDLTTF_CXXFLAGS]) | 22 | AC_SUBST([SDLTTF_CXXFLAGS]) |
23 | 23 | ||
24 | AC_ARG_WITH([sdl-ttf-lib-path], | 24 | AC_ARG_WITH([sdl2-ttf-lib-path], |
25 | [AS_HELP_STRING([--with-sdl-ttf-lib-path], [location of the SDL_ttf library])], | 25 | [AS_HELP_STRING([--with-sdl2-ttf-lib-path], [location of the SDL2_ttf library])], |
26 | [SDLTTF_LIBS="-L$withval -lsdl_ttf"], | 26 | [SDLTTF_LIBS="-L$withval -lsdl2_ttf"], |
27 | [SDLTTF_LIBS="-lsdl_ttf"]) | 27 | [SDLTTF_LIBS="-lsdl2_ttf"]) |
28 | AC_SUBST([SDLTTF_LIBS]) | 28 | AC_SUBST([SDLTTF_LIBS]) |
29 | 29 | ||
30 | dnl Check for SDL_net | 30 | dnl Check for SDL2_net |
31 | AC_ARG_WITH([sdl-net-include-path], | 31 | AC_ARG_WITH([sdl2-net-include-path], |
32 | [AS_HELP_STRING([--with-sdl-net-include-path], | 32 | [AS_HELP_STRING([--with-sdl2-net-include-path], |
33 | [location of the SDL_net headers, defaults to /usr/include/SDL])], | 33 | [location of the SDL2_net headers, defaults to /usr/include/SDL2])], |
34 | [SDLNET_CXXFLAGS="-I$withval"], | 34 | [SDLNET_CXXFLAGS="-I$withval"], |
35 | [SDLNET_CXXFLAGS="-I/usr/include/SDL"]) | 35 | [SDLNET_CXXFLAGS="-I/usr/include/SDL2"]) |
36 | AC_SUBST([SDLNET_CXXFLAGS]) | 36 | AC_SUBST([SDLNET_CXXFLAGS]) |
37 | 37 | ||
38 | AC_ARG_WITH([sdl-net-lib-path], | 38 | AC_ARG_WITH([sdl2-net-lib-path], |
39 | [AS_HELP_STRING([--with-sdl-net-lib-path], [location of the SDL_net library])], | 39 | [AS_HELP_STRING([--with-sdl2-net-lib-path], [location of the SDL2_net library])], |
40 | [SDLNET_LIBS="-L$withval -lsdl_net"], | 40 | [SDLNET_LIBS="-L$withval -lsdl2_net"], |
41 | [SDLNET_LIBS="-lsdl_net"]) | 41 | [SDLNET_LIBS="-lsdl2_net"]) |
42 | AC_SUBST([SDLNET_LIBS]) | 42 | AC_SUBST([SDLNET_LIBS]) |
43 | 43 | ||
44 | AC_OUTPUT \ No newline at end of file | 44 | AC_OUTPUT \ No newline at end of file |
diff --git a/gamestate.cpp b/gamestate.cpp deleted file mode 100644 index fcf865f..0000000 --- a/gamestate.cpp +++ /dev/null | |||
@@ -1,317 +0,0 @@ | |||
1 | #include "includes.h" | ||
2 | |||
3 | GameState::GameState() | ||
4 | { | ||
5 | player_color = getColor(255, 255, 0); | ||
6 | event_color = getColor(0, 0, 255); | ||
7 | |||
8 | newGame = false; | ||
9 | |||
10 | info = new Info(); | ||
11 | info->playerx = 1; | ||
12 | info->playery = 1; | ||
13 | info->level = Level(); | ||
14 | info->doneMaking = false; | ||
15 | board = Board(info); | ||
16 | } | ||
17 | |||
18 | void GameState::input(SDL_keysym key) | ||
19 | { | ||
20 | if (info->doneMaking) | ||
21 | { | ||
22 | switch (key.sym) | ||
23 | { | ||
24 | case SDLK_LEFT: | ||
25 | move(info->playerx-1, info->playery); | ||
26 | |||
27 | break; | ||
28 | case SDLK_RIGHT: | ||
29 | move(info->playerx+1, info->playery); | ||
30 | |||
31 | break; | ||
32 | case SDLK_UP: | ||
33 | move(info->playerx, info->playery-1); | ||
34 | |||
35 | break; | ||
36 | case SDLK_DOWN: | ||
37 | move(info->playerx, info->playery+1); | ||
38 | |||
39 | break; | ||
40 | case SDLK_ESCAPE: | ||
41 | std::ifstream exists(getDataFile()); | ||
42 | if (exists) | ||
43 | { | ||
44 | FILE* hslist = fopen(getDataFile(), "r"); | ||
45 | int scores; | ||
46 | Highscore* h; | ||
47 | |||
48 | fscanf(hslist, "%d%*c", &scores); | ||
49 | |||
50 | if (scores < 10) | ||
51 | { | ||
52 | fclose(hslist); | ||
53 | |||
54 | changeState(new NewHighscoreState(info->level.getLevel())); | ||
55 | } else { | ||
56 | for (int i=0; i<scores; i++) | ||
57 | { | ||
58 | int namelen; | ||
59 | char namelens[4]; | ||
60 | char* name = (char*) calloc(25, sizeof(char)); | ||
61 | int score; | ||
62 | |||
63 | fscanf(hslist, "%d", &namelen); | ||
64 | sprintf(namelens, "%%%dc", namelen); | ||
65 | fscanf(hslist, namelens, name); | ||
66 | fscanf(hslist, "%d%*c", &score); | ||
67 | |||
68 | h = new Highscore(name, score); | ||
69 | } | ||
70 | |||
71 | fclose(hslist); | ||
72 | |||
73 | if (h->getLevel() < info->level.getLevel()) | ||
74 | { | ||
75 | changeState(new NewHighscoreState(info->level.getLevel())); | ||
76 | } else { | ||
77 | changeState(new LocalHighscoreListState(true)); | ||
78 | } | ||
79 | } | ||
80 | } else { | ||
81 | changeState(new NewHighscoreState(info->level.getLevel())); | ||
82 | } | ||
83 | |||
84 | break; | ||
85 | } | ||
86 | } | ||
87 | } | ||
88 | |||
89 | void GameState::tick() | ||
90 | { | ||
91 | if (newGame) | ||
92 | { | ||
93 | switch (rand()%4) | ||
94 | { | ||
95 | case 0: info->playerx = 1; info->playery = 1; break; | ||
96 | case 1: info->playerx = 1; info->playery = HEIGHT-2; break; | ||
97 | case 2: info->playerx = WIDTH-2; info->playery = HEIGHT-2; break; | ||
98 | case 3: info->playerx = WIDTH-2; info->playery = 1; break; | ||
99 | } | ||
100 | |||
101 | info->level.incrementLevel(); | ||
102 | info->doneMaking = false; | ||
103 | info->gens = 0; | ||
104 | board = Board(info); | ||
105 | newGame = false; | ||
106 | } | ||
107 | |||
108 | board.tick(); | ||
109 | } | ||
110 | |||
111 | void GameState::move(int x, int y) | ||
112 | { | ||
113 | wrap(&x, &y); | ||
114 | |||
115 | if (board.isObstructed(x,y)) return; | ||
116 | if ((x==15)&&(y==15)) newGame = true; | ||
117 | |||
118 | info->playerx = x; | ||
119 | info->playery = y; | ||
120 | } | ||
121 | |||
122 | void GameState::render(SDL_Surface* screen) | ||
123 | { | ||
124 | // Paint maze | ||
125 | board.render(screen); | ||
126 | |||
127 | // Paint event | ||
128 | SDL_Rect block; | ||
129 | block.x = 15*16; | ||
130 | block.y = 15*16; | ||
131 | block.w = 16; | ||
132 | block.h = 16; | ||
133 | |||
134 | SDL_FillRect(screen, &block, event_color); | ||
135 | |||
136 | if (!info->doneMaking) | ||
137 | { | ||
138 | SDL_Color fontColor = {0, 0, 0, 0}; | ||
139 | char levelnum[8]; | ||
140 | sprintf(levelnum, "%d", info->level.getLevel()); | ||
141 | SDL_Surface* title = TTF_RenderText_Solid(loadFont(100), levelnum, fontColor); | ||
142 | SDL_Rect tSpace = {240-(title->w/2), 240-(title->h/2), title->w, title->h}; | ||
143 | SDL_FillRect(screen, NULL, info->level.getDeadColor()); | ||
144 | SDL_BlitSurface(title, NULL, screen, &tSpace); | ||
145 | } | ||
146 | |||
147 | // Paint player | ||
148 | block.x = info->playerx*16; | ||
149 | block.y = info->playery*16; | ||
150 | |||
151 | SDL_FillRect(screen, &block, player_color); | ||
152 | } | ||
153 | |||
154 | GameState::Level::Level() | ||
155 | { | ||
156 | level = 0; | ||
157 | |||
158 | alive[0] = getColor(0, 0, 0); // Black | ||
159 | alive[1] = getColor(255, 0, 0); // Red | ||
160 | alive[2] = getColor(0, 255, 0); // Green | ||
161 | alive[3] = getColor(85, 85, 85); // Dark Gray | ||
162 | alive[4] = getColor(255, 0, 255); // Magenta | ||
163 | |||
164 | dead[0] = getColor(255, 255, 255); // White | ||
165 | dead[1] = getColor(255, 192, 203); // Pink | ||
166 | dead[2] = getColor(0, 255, 255); // Cyan | ||
167 | dead[3] = getColor(170, 170, 170); // Light Gray | ||
168 | dead[4] = getColor(255, 128, 0); // Orange | ||
169 | } | ||
170 | |||
171 | int GameState::Level::getLevel() | ||
172 | { | ||
173 | return level; | ||
174 | } | ||
175 | |||
176 | bool GameState::Level::checkSquare(int x, int y) | ||
177 | { | ||
178 | switch (level/10+1) | ||
179 | { | ||
180 | case 1: | ||
181 | return ((x>13)&&(x<17)&&(y>13)&&(y<17)); | ||
182 | case 2: | ||
183 | case 3: | ||
184 | return ((x>12)&&(x<18)&&(y>12)&&(y<18)); | ||
185 | case 4: | ||
186 | case 5: | ||
187 | return ((x>11)&&(x<19)&&(y>11)&&(y<19)); | ||
188 | default: | ||
189 | return true; | ||
190 | } | ||
191 | } | ||
192 | |||
193 | Uint32 GameState::Level::getAliveColor() | ||
194 | { | ||
195 | return alive[(level/10)%5]; | ||
196 | } | ||
197 | |||
198 | Uint32 GameState::Level::getDeadColor() | ||
199 | { | ||
200 | return dead[(level/10)%5]; | ||
201 | } | ||
202 | |||
203 | void GameState::Level::incrementLevel() | ||
204 | { | ||
205 | level++; | ||
206 | } | ||
207 | |||
208 | GameState::Board::Board() | ||
209 | { | ||
210 | GameState::Board::Board(new GameState::Info()); | ||
211 | } | ||
212 | |||
213 | GameState::Board::Board(GameState::Info* info) | ||
214 | { | ||
215 | this->info = info; | ||
216 | |||
217 | int x,y; | ||
218 | for (y=0;y<HEIGHT;y++) | ||
219 | { | ||
220 | for (x=0;x<WIDTH;x++) | ||
221 | { | ||
222 | if (info->level.checkSquare(x, y)) | ||
223 | { | ||
224 | blocks[x][y] = rand() % 2; | ||
225 | } else { | ||
226 | blocks[x][y] = false; | ||
227 | } | ||
228 | } | ||
229 | } | ||
230 | |||
231 | blocks[15][15] = false; | ||
232 | } | ||
233 | |||
234 | bool GameState::Board::isObstructed(int x, int y) | ||
235 | { | ||
236 | return blocks[x][y]; | ||
237 | } | ||
238 | |||
239 | void GameState::Board::render(SDL_Surface* screen) | ||
240 | { | ||
241 | SDL_Rect block; | ||
242 | block.w = 16; | ||
243 | block.h = 16; | ||
244 | |||
245 | int x,y; | ||
246 | |||
247 | for (y=0;y<HEIGHT;y++) | ||
248 | { | ||
249 | for (x=0;x<WIDTH;x++) | ||
250 | { | ||
251 | block.x = x*16; | ||
252 | block.y = y*16; | ||
253 | |||
254 | SDL_FillRect(screen, &block, (blocks[x][y] ? info->level.getAliveColor() : info->level.getDeadColor())); | ||
255 | } | ||
256 | } | ||
257 | } | ||
258 | |||
259 | void GameState::Board::tick() | ||
260 | { | ||
261 | bool temp[WIDTH][HEIGHT]; | ||
262 | int x,y; | ||
263 | for (x=0;x<WIDTH;x++) | ||
264 | { | ||
265 | for (y=0;y<HEIGHT;y++) | ||
266 | { | ||
267 | temp[x][y] = blocks[x][y]; | ||
268 | } | ||
269 | } | ||
270 | |||
271 | for (x=0;x<WIDTH;x++) | ||
272 | { | ||
273 | for (y=0;y<HEIGHT;y++) | ||
274 | { | ||
275 | if ((x==15)&&(y==15)) | ||
276 | { | ||
277 | continue; | ||
278 | } | ||
279 | |||
280 | int neighbors = 0; | ||
281 | |||
282 | incrementIfNeighbor(x-1,y-1,temp,&neighbors); | ||
283 | incrementIfNeighbor(x-1,y,temp,&neighbors); | ||
284 | incrementIfNeighbor(x-1,y+1,temp,&neighbors); | ||
285 | incrementIfNeighbor(x,y-1,temp,&neighbors); | ||
286 | incrementIfNeighbor(x,y+1,temp,&neighbors); | ||
287 | incrementIfNeighbor(x+1,y-1,temp,&neighbors); | ||
288 | incrementIfNeighbor(x+1,y,temp,&neighbors); | ||
289 | incrementIfNeighbor(x+1,y+1,temp,&neighbors); | ||
290 | |||
291 | if (temp[x][y]) | ||
292 | { | ||
293 | blocks[x][y] = ((neighbors >= 1) && (neighbors <= 4)); | ||
294 | } else { | ||
295 | blocks[x][y] = (neighbors == 3); | ||
296 | } | ||
297 | } | ||
298 | } | ||
299 | |||
300 | if (!info->doneMaking && ++info->gens > 50) info->doneMaking = true; | ||
301 | } | ||
302 | |||
303 | void GameState::Board::incrementIfNeighbor(int x, int y, bool temp[WIDTH][HEIGHT], int* tick) | ||
304 | { | ||
305 | int nx = x; | ||
306 | int ny = y; | ||
307 | |||
308 | wrap(&x, &y); | ||
309 | |||
310 | if (!((nx!=x)&&(ny!=y))) | ||
311 | { | ||
312 | if ((temp[x][y])||((info->playerx==x)&&(info->playery==y))||((x==15)&&(y==15))) | ||
313 | { | ||
314 | ++*tick; | ||
315 | } | ||
316 | } | ||
317 | } | ||
diff --git a/gamestate.h b/gamestate.h deleted file mode 100644 index 28b85c0..0000000 --- a/gamestate.h +++ /dev/null | |||
@@ -1,59 +0,0 @@ | |||
1 | #ifndef GAMESTATE_H | ||
2 | #define GAMESTATE_H | ||
3 | |||
4 | class GameState : public State { | ||
5 | public: | ||
6 | GameState(); | ||
7 | void input(SDL_keysym key); | ||
8 | void tick(); | ||
9 | void render(SDL_Surface* screen); | ||
10 | |||
11 | class Level | ||
12 | { | ||
13 | private: | ||
14 | int level; | ||
15 | Uint32 alive[5]; | ||
16 | Uint32 dead[5]; | ||
17 | |||
18 | public: | ||
19 | Level(); | ||
20 | int getLevel(); | ||
21 | int getLevelGroup(); | ||
22 | bool checkSquare(int x, int y); | ||
23 | Uint32 getAliveColor(); | ||
24 | Uint32 getDeadColor(); | ||
25 | void incrementLevel(); | ||
26 | }; | ||
27 | |||
28 | struct Info { | ||
29 | int playerx, playery; | ||
30 | Level level; | ||
31 | bool doneMaking; | ||
32 | int gens; | ||
33 | }; | ||
34 | |||
35 | class Board | ||
36 | { | ||
37 | private: | ||
38 | bool blocks[WIDTH][HEIGHT]; | ||
39 | void incrementIfNeighbor(int x, int y, bool temp[WIDTH][HEIGHT], int* tick); | ||
40 | GameState::Info* info; | ||
41 | |||
42 | public: | ||
43 | Board(); | ||
44 | Board(GameState::Info* info); | ||
45 | bool isObstructed(int x, int y); | ||
46 | void render(SDL_Surface* screen); | ||
47 | void tick(); | ||
48 | }; | ||
49 | |||
50 | private: | ||
51 | Uint32 player_color; | ||
52 | Uint32 event_color; | ||
53 | bool newGame; | ||
54 | Info* info; | ||
55 | Board board; | ||
56 | void move(int x, int y); | ||
57 | }; | ||
58 | |||
59 | #endif | ||
diff --git a/highscore.cpp b/highscore.cpp index 6811fa8..7133e1a 100644 --- a/highscore.cpp +++ b/highscore.cpp | |||
@@ -1,4 +1,4 @@ | |||
1 | #include "includes.h" | 1 | #include "highscore.h" |
2 | 2 | ||
3 | Highscore::Highscore(char* name, int level) | 3 | Highscore::Highscore(char* name, int level) |
4 | { | 4 | { |
diff --git a/hsglobal.cpp b/hsglobal.cpp deleted file mode 100644 index 3076403..0000000 --- a/hsglobal.cpp +++ /dev/null | |||
@@ -1,63 +0,0 @@ | |||
1 | #include "includes.h" | ||
2 | |||
3 | GlobalHighscoreListState::GlobalHighscoreListState() | ||
4 | { | ||
5 | options = SDL_LoadBMP("resources/hlo_rtm.bmp"); | ||
6 | pointer = SDL_LoadBMP("resources/pointer.bmp"); | ||
7 | |||
8 | list = SDL_CreateRGBSurface(SDL_SWSURFACE || SDL_SRCCOLORKEY, 480, 480, 32, 0,0,0,0); | ||
9 | Uint32 bgColor = SDL_MapRGB(list->format, 255, 255, 255); | ||
10 | SDL_FillRect(list, NULL, bgColor); | ||
11 | SDL_SetColorKey(list, SDL_SRCCOLORKEY, bgColor); | ||
12 | TTF_Font* dataFont = loadFont(25); | ||
13 | SDL_Color fontColor = {0, 0, 0, 0}; | ||
14 | SDL_Surface* text = TTF_RenderText_Blended(dataFont, "Fetching highscores....", fontColor); | ||
15 | SDL_Rect aSpace = {240-(text->w/2), 240-(text->h/2), text->w, text->h}; | ||
16 | SDL_BlitSurface(text, NULL, list, &aSpace); | ||
17 | |||
18 | SDL_Surface* title = TTF_RenderText_Blended(loadFont(40), "Highscore List", fontColor); | ||
19 | SDL_Rect tSpace = {240-(title->w/2), 0, title->w, title->h}; | ||
20 | SDL_BlitSurface(title, NULL, list, &tSpace); | ||
21 | |||
22 | SDL_Rect oSpace = {0, 440, options->w, options->h}; | ||
23 | SDL_BlitSurface(options, NULL, list, &oSpace); | ||
24 | |||
25 | SDL_CreateThread(&LoadHighscoreList, this); | ||
26 | } | ||
27 | |||
28 | int GlobalHighscoreListState::LoadHighscoreList(void* pParam) | ||
29 | { | ||
30 | GlobalHighscoreList* lhl = new GlobalHighscoreList(); | ||
31 | ((GlobalHighscoreListState*)pParam)->list = lhl->render(); | ||
32 | |||
33 | SDL_Color fontColor = {0, 0, 0, 0}; | ||
34 | SDL_Surface* title = TTF_RenderText_Blended(loadFont(40), "Highscore List", fontColor); | ||
35 | SDL_Rect tSpace = {240-(title->w/2), 0, title->w, title->h}; | ||
36 | SDL_BlitSurface(title, NULL, ((GlobalHighscoreListState*)pParam)->list, &tSpace); | ||
37 | |||
38 | SDL_Rect oSpace = {0, 440, ((GlobalHighscoreListState*)pParam)->options->w, ((GlobalHighscoreListState*)pParam)->options->h}; | ||
39 | SDL_BlitSurface(((GlobalHighscoreListState*)pParam)->options, NULL, ((GlobalHighscoreListState*)pParam)->list, &oSpace); | ||
40 | } | ||
41 | |||
42 | void GlobalHighscoreListState::input(SDL_keysym key) | ||
43 | { | ||
44 | if (key.sym == SDLK_RETURN) | ||
45 | { | ||
46 | changeState(new ChooseHighscoreListState()); | ||
47 | } | ||
48 | } | ||
49 | |||
50 | void GlobalHighscoreListState::render(SDL_Surface* screen) | ||
51 | { | ||
52 | SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 255, 255, 255)); | ||
53 | |||
54 | SDL_BlitSurface(list, NULL, screen, NULL); | ||
55 | |||
56 | SDL_Rect pSpace; | ||
57 | pSpace.x = 137; | ||
58 | pSpace.y = 449; | ||
59 | pSpace.w = pointer->w; | ||
60 | pSpace.h = pointer->h; | ||
61 | |||
62 | SDL_BlitSurface(pointer, NULL, screen, &pSpace); | ||
63 | } | ||
diff --git a/hsglobal.h b/hsglobal.h deleted file mode 100644 index 5b92b0e..0000000 --- a/hsglobal.h +++ /dev/null | |||
@@ -1,18 +0,0 @@ | |||
1 | #ifndef HSGLOBAL_H | ||
2 | #define HSGLOBAL_H | ||
3 | |||
4 | class GlobalHighscoreListState : public State { | ||
5 | public: | ||
6 | GlobalHighscoreListState(); | ||
7 | void input(SDL_keysym key); | ||
8 | void render(SDL_Surface* screen); | ||
9 | |||
10 | private: | ||
11 | static int LoadHighscoreList(void* pParam); | ||
12 | |||
13 | SDL_Surface* list; | ||
14 | SDL_Surface* options; | ||
15 | SDL_Surface* pointer; | ||
16 | }; | ||
17 | |||
18 | #endif | ||
diff --git a/hslist.cpp b/hslist.cpp index ec99a77..80e0801 100644 --- a/hslist.cpp +++ b/hslist.cpp | |||
@@ -1,11 +1,16 @@ | |||
1 | #include "includes.h" | 1 | #include "hslist.h" |
2 | #include <SDL_ttf.h> | ||
3 | #include <SDL_net.h> | ||
4 | #include <sstream> | ||
5 | #include <fstream> | ||
6 | #include "util.h" | ||
2 | 7 | ||
3 | SDL_Surface* HighscoreList::render() | 8 | SDL_Surface* HighscoreList::render() |
4 | { | 9 | { |
5 | SDL_Surface* tmp = SDL_CreateRGBSurface(SDL_SWSURFACE || SDL_SRCCOLORKEY, 480, 480, 32, 0,0,0,0); | 10 | SDL_Surface* tmp = SDL_CreateRGBSurface(0, 480, 480, 32, 0,0,0,0); |
6 | Uint32 bgColor = SDL_MapRGB(tmp->format, 255, 255, 255); | 11 | Uint32 bgColor = SDL_MapRGB(tmp->format, 255, 255, 255); |
7 | SDL_FillRect(tmp, NULL, bgColor); | 12 | SDL_FillRect(tmp, NULL, bgColor); |
8 | SDL_SetColorKey(tmp, SDL_SRCCOLORKEY, bgColor); | 13 | SDL_SetColorKey(tmp, SDL_TRUE, bgColor); |
9 | TTF_Font* posFont = loadFont(40); | 14 | TTF_Font* posFont = loadFont(40); |
10 | TTF_Font* dataFont = loadFont(25); | 15 | TTF_Font* dataFont = loadFont(25); |
11 | SDL_Color fontColor = {0, 0, 0, 0}; | 16 | SDL_Color fontColor = {0, 0, 0, 0}; |
@@ -181,10 +186,10 @@ SDL_Surface* GlobalHighscoreList::render() | |||
181 | { | 186 | { |
182 | if (fail) | 187 | if (fail) |
183 | { | 188 | { |
184 | SDL_Surface* tmp = SDL_CreateRGBSurface(SDL_SWSURFACE || SDL_SRCCOLORKEY, 480, 480, 32, 0,0,0,0); | 189 | SDL_Surface* tmp = SDL_CreateRGBSurface(0, 480, 480, 32, 0,0,0,0); |
185 | Uint32 bgColor = SDL_MapRGB(tmp->format, 255, 255, 255); | 190 | Uint32 bgColor = SDL_MapRGB(tmp->format, 255, 255, 255); |
186 | SDL_FillRect(tmp, NULL, bgColor); | 191 | SDL_FillRect(tmp, NULL, bgColor); |
187 | SDL_SetColorKey(tmp, SDL_SRCCOLORKEY, bgColor); | 192 | SDL_SetColorKey(tmp, SDL_TRUE, bgColor); |
188 | TTF_Font* dataFont = loadFont(25); | 193 | TTF_Font* dataFont = loadFont(25); |
189 | SDL_Color fontColor = {0, 0, 0, 0}; | 194 | SDL_Color fontColor = {0, 0, 0, 0}; |
190 | SDL_Surface* text = TTF_RenderText_Blended(dataFont, "Error retrieving highscores", fontColor); | 195 | SDL_Surface* text = TTF_RenderText_Blended(dataFont, "Error retrieving highscores", fontColor); |
diff --git a/hslist.h b/hslist.h index bebb85a..80e1c31 100644 --- a/hslist.h +++ b/hslist.h | |||
@@ -1,3 +1,7 @@ | |||
1 | #include <SDL.h> | ||
2 | #include <vector> | ||
3 | #include "highscore.h" | ||
4 | |||
1 | #ifndef HSLIST_H | 5 | #ifndef HSLIST_H |
2 | #define HSLIST_H | 6 | #define HSLIST_H |
3 | 7 | ||
diff --git a/hslocal.cpp b/hslocal.cpp deleted file mode 100644 index eec87e2..0000000 --- a/hslocal.cpp +++ /dev/null | |||
@@ -1,82 +0,0 @@ | |||
1 | #include "includes.h" | ||
2 | |||
3 | LocalHighscoreListState::LocalHighscoreListState(bool fromGame) | ||
4 | { | ||
5 | this->fromGame = fromGame; | ||
6 | |||
7 | if (fromGame) | ||
8 | { | ||
9 | options = SDL_LoadBMP("resources/hlo_paartm.bmp"); | ||
10 | } else { | ||
11 | options = SDL_LoadBMP("resources/hlo_rtm.bmp"); | ||
12 | } | ||
13 | |||
14 | pointer = SDL_LoadBMP("resources/pointer.bmp"); | ||
15 | |||
16 | LocalHighscoreList* lhl = new LocalHighscoreList(); | ||
17 | list = lhl->render(); | ||
18 | |||
19 | SDL_Color fontColor = {0, 0, 0, 0}; | ||
20 | SDL_Surface* title = TTF_RenderText_Blended(loadFont(40), "Highscore List", fontColor); | ||
21 | SDL_Rect tSpace = {240-(title->w/2), 0, title->w, title->h}; | ||
22 | SDL_BlitSurface(title, NULL, list, &tSpace); | ||
23 | |||
24 | SDL_Rect oSpace = {0, 440, options->w, options->h}; | ||
25 | SDL_BlitSurface(options, NULL, list, &oSpace); | ||
26 | |||
27 | selection = 0; | ||
28 | } | ||
29 | |||
30 | void LocalHighscoreListState::input(SDL_keysym key) | ||
31 | { | ||
32 | if (fromGame) | ||
33 | { | ||
34 | if ((key.sym == SDLK_LEFT) && (selection != 0)) | ||
35 | { | ||
36 | selection--; | ||
37 | } else if ((key.sym == SDLK_RIGHT) && (selection != 1)) | ||
38 | { | ||
39 | selection++; | ||
40 | } else if (key.sym == SDLK_RETURN) | ||
41 | { | ||
42 | switch (selection) | ||
43 | { | ||
44 | case 0: | ||
45 | changeState(new GameState()); | ||
46 | |||
47 | break; | ||
48 | case 1: | ||
49 | changeState(new TitleState()); | ||
50 | |||
51 | break; | ||
52 | } | ||
53 | } | ||
54 | } else { | ||
55 | if (key.sym == SDLK_RETURN) | ||
56 | { | ||
57 | changeState(new ChooseHighscoreListState()); | ||
58 | } | ||
59 | } | ||
60 | } | ||
61 | |||
62 | void LocalHighscoreListState::render(SDL_Surface* screen) | ||
63 | { | ||
64 | SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 255, 255, 255)); | ||
65 | |||
66 | SDL_BlitSurface(list, NULL, screen, NULL); | ||
67 | |||
68 | SDL_Rect pSpace; | ||
69 | pSpace.w = pointer->w; | ||
70 | pSpace.h = pointer->h; | ||
71 | |||
72 | if (fromGame) | ||
73 | { | ||
74 | pSpace.x = (selection==0?52:225); | ||
75 | pSpace.y = 447; | ||
76 | } else { | ||
77 | pSpace.x = 137; | ||
78 | pSpace.y = 449; | ||
79 | } | ||
80 | |||
81 | SDL_BlitSurface(pointer, NULL, screen, &pSpace); | ||
82 | } | ||
diff --git a/hslocal.h b/hslocal.h deleted file mode 100644 index 8708d03..0000000 --- a/hslocal.h +++ /dev/null | |||
@@ -1,18 +0,0 @@ | |||
1 | #ifndef HSLOCAL_H | ||
2 | #define HSLOCAL_H | ||
3 | |||
4 | class LocalHighscoreListState : public State { | ||
5 | public: | ||
6 | LocalHighscoreListState(bool fromGame); | ||
7 | void input(SDL_keysym key); | ||
8 | void render(SDL_Surface* screen); | ||
9 | |||
10 | private: | ||
11 | SDL_Surface* list; | ||
12 | SDL_Surface* options; | ||
13 | SDL_Surface* pointer; | ||
14 | int selection; | ||
15 | bool fromGame; | ||
16 | }; | ||
17 | |||
18 | #endif | ||
diff --git a/hsnew.cpp b/hsnew.cpp deleted file mode 100644 index b4894c2..0000000 --- a/hsnew.cpp +++ /dev/null | |||
@@ -1,220 +0,0 @@ | |||
1 | #include "includes.h" | ||
2 | |||
3 | NewHighscoreState::NewHighscoreState(int level) | ||
4 | { | ||
5 | this->level = level; | ||
6 | |||
7 | options = SDL_LoadBMP("resources/hlo_passartm.bmp"); | ||
8 | pointer = SDL_LoadBMP("resources/pointer.bmp"); | ||
9 | |||
10 | lhl = new NewHighscoreList(level); | ||
11 | newpos = lhl->getNewPos(); | ||
12 | list = lhl->render(); | ||
13 | |||
14 | SDL_Color fontColor = {0, 0, 0, 0}; | ||
15 | SDL_Surface* title = TTF_RenderText_Blended(loadFont(40), "New Highscore!", fontColor); | ||
16 | SDL_Rect tSpace = {240-(title->w/2), 0, title->w, title->h}; | ||
17 | SDL_BlitSurface(title, NULL, list, &tSpace); | ||
18 | |||
19 | this->enterName = true; | ||
20 | this->lp = 0; | ||
21 | this->hsname = (char*) calloc(25, sizeof(char)); | ||
22 | |||
23 | SDL_Surface* text = TTF_RenderText_Blended(loadFont(25), "Enter Your Name", fontColor); | ||
24 | SDL_Rect oSpace = {240-(text->w/2), 440, text->w, text->h}; | ||
25 | SDL_BlitSurface(text, NULL, list, &oSpace); | ||
26 | |||
27 | selection = 0; | ||
28 | |||
29 | int posw, posh; | ||
30 | char pos[3]; // 2 max characters in rank plus the colon at the end | ||
31 | sprintf(pos, "%d:", newpos); | ||
32 | char name[26]; // 25 max characters in username plus the space at the beginning | ||
33 | sprintf(name, " %s", hsname); | ||
34 | newName = TTF_RenderText_Blended(loadFont(25), name, fontColor); | ||
35 | TTF_SizeText(loadFont(40), pos, &posw, &posh); | ||
36 | rntSpace.x = posw; | ||
37 | rntSpace.y = newpos*40+((posh/2)-(newName->h/2)); | ||
38 | rntSpace.w = newName->w; | ||
39 | rntSpace.h = newName->h; | ||
40 | |||
41 | SDL_EnableUNICODE(1); | ||
42 | } | ||
43 | |||
44 | void NewHighscoreState::input(SDL_keysym key) | ||
45 | { | ||
46 | if (enterName) | ||
47 | { | ||
48 | if ((key.sym == SDLK_BACKSPACE) && (lp > 0)) | ||
49 | { | ||
50 | hsname[--lp] = 0; | ||
51 | |||
52 | SDL_Color fontColor = {0, 0, 0, 0}; | ||
53 | char name[26]; // 25 max characters in username plus the space at the beginning | ||
54 | sprintf(name, " %s", hsname); | ||
55 | newName = TTF_RenderText_Blended(loadFont(25), name, fontColor); | ||
56 | rntSpace.w = newName->w; | ||
57 | rntSpace.h = newName->h; | ||
58 | } else if ((key.sym == SDLK_RETURN) && (hsname[0] != 0)) | ||
59 | { | ||
60 | SDL_EnableUNICODE(0); | ||
61 | enterName = false; | ||
62 | |||
63 | lhl->addToList(hsname); | ||
64 | LocalHighscoreList* lhl2 = new LocalHighscoreList(); | ||
65 | list = lhl2->render(); | ||
66 | |||
67 | SDL_Color fontColor = {0, 0, 0, 0}; | ||
68 | SDL_Surface* title = TTF_RenderText_Blended(loadFont(40), "New Highscore!", fontColor); | ||
69 | SDL_Rect tSpace = {240-(title->w/2), 0, title->w, title->h}; | ||
70 | SDL_BlitSurface(title, NULL, list, &tSpace); | ||
71 | |||
72 | SDL_Rect oSpace = {0, 440, options->w, options->h}; | ||
73 | SDL_BlitSurface(options, NULL, list, &oSpace); | ||
74 | } else if (((key.unicode & 0xFF80) == 0) && (key.unicode >= 32 && key.unicode < 127) && (lp < 25)) | ||
75 | { | ||
76 | hsname[lp++] = key.unicode & 0x7f; | ||
77 | hsname[lp] = 0; | ||
78 | |||
79 | SDL_Color fontColor = {0, 0, 0, 0}; | ||
80 | char name[26]; // 25 max characters in username plus the space at the beginning | ||
81 | sprintf(name, " %s", hsname); | ||
82 | newName = TTF_RenderText_Blended(loadFont(25), name, fontColor); | ||
83 | rntSpace.w = newName->w; | ||
84 | rntSpace.h = newName->h; | ||
85 | } | ||
86 | } else { | ||
87 | if ((key.sym == SDLK_LEFT) && (selection != 0)) | ||
88 | { | ||
89 | selection--; | ||
90 | } else if ((key.sym == SDLK_RIGHT) && (selection != 2)) | ||
91 | { | ||
92 | selection++; | ||
93 | } else if (key.sym == SDLK_RETURN) | ||
94 | { | ||
95 | switch (selection) | ||
96 | { | ||
97 | case 0: | ||
98 | changeState(new GameState()); | ||
99 | |||
100 | break; | ||
101 | case 1: | ||
102 | changeState(new SubmitHighscoreListState(hsname, level)); | ||
103 | |||
104 | break; | ||
105 | case 2: | ||
106 | changeState(new TitleState()); | ||
107 | |||
108 | break; | ||
109 | } | ||
110 | } | ||
111 | } | ||
112 | } | ||
113 | |||
114 | void NewHighscoreState::render(SDL_Surface* screen) | ||
115 | { | ||
116 | SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 255, 255, 255)); | ||
117 | |||
118 | SDL_Rect eSpace = {0, newpos*40, 480, 40}; | ||
119 | SDL_FillRect(screen, &eSpace, SDL_MapRGB(screen->format, 255, 255, 0)); | ||
120 | |||
121 | SDL_BlitSurface(list, NULL, screen, NULL); | ||
122 | |||
123 | if (enterName) | ||
124 | { | ||
125 | SDL_BlitSurface(newName, NULL, screen, &rntSpace); | ||
126 | } else { | ||
127 | SDL_Rect pSpace; | ||
128 | pSpace.x = (selection==0?13:(selection==1?138:284)); | ||
129 | pSpace.y = 448; | ||
130 | pSpace.w = pointer->w; | ||
131 | pSpace.h = pointer->h; | ||
132 | |||
133 | SDL_BlitSurface(pointer, NULL, screen, &pSpace); | ||
134 | } | ||
135 | } | ||
136 | |||
137 | NewHighscoreState::NewHighscoreList::NewHighscoreList(int level) | ||
138 | { | ||
139 | this->hslist = getLocalHighscores(); | ||
140 | |||
141 | if (this->hslist.empty()) | ||
142 | { | ||
143 | Highscore n = Highscore("", level); | ||
144 | n.setRank(1); | ||
145 | |||
146 | this->hslist.push_back(n); | ||
147 | this->newpos = n.getRank(); | ||
148 | } else { | ||
149 | std::vector<Highscore>::iterator it; | ||
150 | bool found = false; | ||
151 | int lastrank; | ||
152 | int i=0; | ||
153 | |||
154 | for (it=this->hslist.begin(); it<this->hslist.end(); it++) | ||
155 | { | ||
156 | Highscore h = *it; | ||
157 | lastrank = h.getRank(); | ||
158 | |||
159 | if (!found) | ||
160 | { | ||
161 | if (h.getLevel() < level) | ||
162 | { | ||
163 | Highscore n = Highscore("", level); | ||
164 | n.setRank(h.getRank()); | ||
165 | |||
166 | this->hslist.insert(it, n); | ||
167 | this->newpos = n.getRank(); | ||
168 | |||
169 | if (this->hslist.size() > 10) | ||
170 | { | ||
171 | this->hslist.pop_back(); | ||
172 | } | ||
173 | |||
174 | found = true; | ||
175 | } | ||
176 | } else { | ||
177 | //this->hslist[i].setRank(h.getRank()+1); | ||
178 | } | ||
179 | |||
180 | i++; | ||
181 | } | ||
182 | |||
183 | if (!found) | ||
184 | { | ||
185 | Highscore n = Highscore("", level); | ||
186 | n.setRank(lastrank+1); | ||
187 | |||
188 | this->hslist.push_back(n); | ||
189 | this->newpos = n.getRank(); | ||
190 | } | ||
191 | } | ||
192 | } | ||
193 | |||
194 | int NewHighscoreState::NewHighscoreList::getNewPos() | ||
195 | { | ||
196 | return newpos; | ||
197 | } | ||
198 | |||
199 | void NewHighscoreState::NewHighscoreList::addToList(char* name) | ||
200 | { | ||
201 | FILE* hsfile = fopen(getDataFile(), "w"); | ||
202 | fprintf(hsfile, "%d ", this->hslist.size()); | ||
203 | |||
204 | std::vector<Highscore>::iterator it; | ||
205 | |||
206 | for (it=this->hslist.begin(); it<this->hslist.end(); it++) | ||
207 | { | ||
208 | Highscore h = *it; | ||
209 | |||
210 | if (h.getName() == "") | ||
211 | { | ||
212 | h = Highscore(name, h.getLevel()); | ||
213 | h.setRank(newpos); | ||
214 | } | ||
215 | |||
216 | fprintf(hsfile, "%d%s%d ", strlen(h.getName()), h.getName(), h.getLevel()); | ||
217 | } | ||
218 | |||
219 | fclose(hsfile); | ||
220 | } | ||
diff --git a/hsnew.h b/hsnew.h deleted file mode 100644 index 123ac53..0000000 --- a/hsnew.h +++ /dev/null | |||
@@ -1,35 +0,0 @@ | |||
1 | #ifndef HSNEW_H | ||
2 | #define HSNEW_H | ||
3 | |||
4 | class NewHighscoreState : public State { | ||
5 | public: | ||
6 | NewHighscoreState(int level); | ||
7 | void input(SDL_keysym key); | ||
8 | void render(SDL_Surface* screen); | ||
9 | |||
10 | private: | ||
11 | class NewHighscoreList : public HighscoreList { | ||
12 | public: | ||
13 | NewHighscoreList(int level); | ||
14 | int getNewPos(); | ||
15 | void addToList(char* name); | ||
16 | |||
17 | private: | ||
18 | int newpos; | ||
19 | }; | ||
20 | |||
21 | SDL_Surface* list; | ||
22 | SDL_Surface* options; | ||
23 | SDL_Surface* pointer; | ||
24 | int selection; | ||
25 | int level; | ||
26 | int newpos; | ||
27 | int lp; | ||
28 | char* hsname; | ||
29 | bool enterName; | ||
30 | SDL_Rect rntSpace; | ||
31 | SDL_Surface* newName; | ||
32 | NewHighscoreList* lhl; | ||
33 | }; | ||
34 | |||
35 | #endif | ||
diff --git a/hssubmit.cpp b/hssubmit.cpp deleted file mode 100644 index eaacb88..0000000 --- a/hssubmit.cpp +++ /dev/null | |||
@@ -1,226 +0,0 @@ | |||
1 | #include "includes.h" | ||
2 | |||
3 | SubmitHighscoreListState::SubmitHighscoreListState(char* hsname, int level) | ||
4 | { | ||
5 | pointer = SDL_LoadBMP("resources/pointer.bmp"); | ||
6 | |||
7 | this->hsname = hsname; | ||
8 | this->level = level; | ||
9 | this->scoreSent = false; | ||
10 | this->selection = 0; | ||
11 | |||
12 | list = SDL_CreateRGBSurface(SDL_SWSURFACE || SDL_SRCCOLORKEY, 480, 480, 32, 0,0,0,0); | ||
13 | Uint32 bgColor = SDL_MapRGB(list->format, 255, 255, 255); | ||
14 | SDL_FillRect(list, NULL, bgColor); | ||
15 | SDL_SetColorKey(list, SDL_SRCCOLORKEY, bgColor); | ||
16 | TTF_Font* dataFont = loadFont(25); | ||
17 | SDL_Color fontColor = {0, 0, 0, 0}; | ||
18 | SDL_Surface* text = TTF_RenderText_Blended(dataFont, "Sending highscore....", fontColor); | ||
19 | SDL_Rect aSpace = {240-(text->w/2), 240-(text->h/2), text->w, text->h}; | ||
20 | SDL_BlitSurface(text, NULL, list, &aSpace); | ||
21 | |||
22 | SDL_Surface* title = TTF_RenderText_Blended(loadFont(40), "Highscore List", fontColor); | ||
23 | SDL_Rect tSpace = {240-(title->w/2), 0, title->w, title->h}; | ||
24 | SDL_BlitSurface(title, NULL, list, &tSpace); | ||
25 | |||
26 | SDL_CreateThread(&LoadHighscoreList, this); | ||
27 | } | ||
28 | |||
29 | int SubmitHighscoreListState::LoadHighscoreList(void* pParam) | ||
30 | { | ||
31 | SubmitHighscoreList* lhl = new SubmitHighscoreList(((SubmitHighscoreListState*)pParam)->hsname, ((SubmitHighscoreListState*)pParam)->level); | ||
32 | ((SubmitHighscoreListState*)pParam)->list = lhl->render(); | ||
33 | |||
34 | SDL_Color fontColor = {0, 0, 0, 0}; | ||
35 | SDL_Surface* title = TTF_RenderText_Blended(loadFont(40), "Highscore List", fontColor); | ||
36 | SDL_Rect tSpace = {240-(title->w/2), 0, title->w, title->h}; | ||
37 | SDL_BlitSurface(title, NULL, ((SubmitHighscoreListState*)pParam)->list, &tSpace); | ||
38 | |||
39 | if (lhl->hasFailed()) | ||
40 | { | ||
41 | ((SubmitHighscoreListState*)pParam)->options = SDL_LoadBMP("resources/hlo_passartm.bmp"); | ||
42 | } else { | ||
43 | ((SubmitHighscoreListState*)pParam)->options = SDL_LoadBMP("resources/hlo_paartm.bmp"); | ||
44 | } | ||
45 | |||
46 | SDL_Rect oSpace = {0, 440, ((SubmitHighscoreListState*)pParam)->options->w, ((SubmitHighscoreListState*)pParam)->options->h}; | ||
47 | SDL_BlitSurface(((SubmitHighscoreListState*)pParam)->options, NULL, ((SubmitHighscoreListState*)pParam)->list, &oSpace); | ||
48 | |||
49 | ((SubmitHighscoreListState*)pParam)->fail = lhl->hasFailed(); | ||
50 | ((SubmitHighscoreListState*)pParam)->newpos = lhl->getNewPos(); | ||
51 | ((SubmitHighscoreListState*)pParam)->scoreSent = true; | ||
52 | } | ||
53 | |||
54 | void SubmitHighscoreListState::input(SDL_keysym key) | ||
55 | { | ||
56 | if (scoreSent) | ||
57 | { | ||
58 | if ((key.sym == SDLK_LEFT) && (selection != 0)) | ||
59 | { | ||
60 | selection--; | ||
61 | } else if ((key.sym == SDLK_RIGHT) && (selection != (fail?2:1))) | ||
62 | { | ||
63 | selection++; | ||
64 | } else if (key.sym == SDLK_RETURN) | ||
65 | { | ||
66 | if (fail) | ||
67 | { | ||
68 | switch (selection) | ||
69 | { | ||
70 | case 0: | ||
71 | changeState(new GameState()); | ||
72 | |||
73 | break; | ||
74 | case 1: | ||
75 | changeState(new SubmitHighscoreListState(hsname, level)); | ||
76 | |||
77 | break; | ||
78 | case 2: | ||
79 | changeState(new TitleState()); | ||
80 | |||
81 | break; | ||
82 | } | ||
83 | } else { | ||
84 | switch (selection) | ||
85 | { | ||
86 | case 0: | ||
87 | changeState(new GameState()); | ||
88 | |||
89 | break; | ||
90 | case 1: | ||
91 | changeState(new TitleState()); | ||
92 | |||
93 | break; | ||
94 | } | ||
95 | } | ||
96 | } | ||
97 | } | ||
98 | } | ||
99 | |||
100 | void SubmitHighscoreListState::render(SDL_Surface* screen) | ||
101 | { | ||
102 | SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 255, 255, 255)); | ||
103 | |||
104 | if (scoreSent) | ||
105 | { | ||
106 | SDL_Rect pSpace; | ||
107 | if (fail) | ||
108 | { | ||
109 | pSpace.x = (selection==0?13:(selection==1?138:284)); | ||
110 | pSpace.y = 448; | ||
111 | } else { | ||
112 | pSpace.x = (selection==0?52:225); | ||
113 | pSpace.y = 447; | ||
114 | } | ||
115 | pSpace.w = pointer->w; | ||
116 | pSpace.h = pointer->h; | ||
117 | |||
118 | SDL_BlitSurface(pointer, NULL, screen, &pSpace); | ||
119 | |||
120 | SDL_Rect eSpace = {0, newpos*40, 480, 40}; | ||
121 | SDL_FillRect(screen, &eSpace, SDL_MapRGB(screen->format, 255, 255, 0)); | ||
122 | } | ||
123 | |||
124 | SDL_BlitSurface(list, NULL, screen, NULL); | ||
125 | } | ||
126 | |||
127 | SubmitHighscoreListState::SubmitHighscoreList::SubmitHighscoreList(char* hsname, int level) | ||
128 | { | ||
129 | fail = false; | ||
130 | |||
131 | try | ||
132 | { | ||
133 | IPaddress ipaddress; | ||
134 | |||
135 | if (SDLNet_ResolveHost(&ipaddress, "other.fourisland.com", 80) == -1) | ||
136 | { | ||
137 | printf("Could not resolve host \"other.fourisland.com\": %s\n", SDLNet_GetError()); | ||
138 | throw 1; | ||
139 | } | ||
140 | |||
141 | TCPsocket tcpsock = SDLNet_TCP_Open(&ipaddress); | ||
142 | if (!tcpsock) | ||
143 | { | ||
144 | printf("Could not connect to host \"other.fourisland.com\": %s\n", SDLNet_GetError()); | ||
145 | throw 2; | ||
146 | } | ||
147 | |||
148 | char body[256]; | ||
149 | sprintf(body, "name=%s&level=%d", hsname, level); | ||
150 | char headers[256]; | ||
151 | sprintf(headers, "POST /mol/hslist.php?add HTTP/1.1\nHost: other.fourisland.com\nUser-Agent: Maze Of Life v2.0\nAccept: text/plain\nKeep-Alive: 300\nConnection: keep-alive\nContent-Type: application/x-www-form-urlencoded\nContent-Length: %d\n\n%s\n", strlen(body), body); | ||
152 | if (SDLNet_TCP_Send(tcpsock, headers, strlen(headers)+1) < strlen(headers)) | ||
153 | { | ||
154 | printf("Connection closed by peer: %s\n", SDLNet_GetError()); | ||
155 | throw 3; | ||
156 | } | ||
157 | |||
158 | std::stringstream download(std::stringstream::in | std::stringstream::out); | ||
159 | char hslist[1024]; | ||
160 | SDLNet_TCP_Recv(tcpsock, hslist, 1024); | ||
161 | download << hslist; | ||
162 | SDLNet_TCP_Close(tcpsock); | ||
163 | |||
164 | char temps[256]; | ||
165 | download.getline(temps,256); | ||
166 | while (strlen(temps) != 1) | ||
167 | { | ||
168 | download.getline(temps,256); | ||
169 | } | ||
170 | |||
171 | int rank; | ||
172 | download.getline(temps, 256); | ||
173 | if (sscanf(temps, "%d%*c", &rank) != 1) | ||
174 | { | ||
175 | printf("Recieved data is of an invalid format: %s\n", temps); | ||
176 | throw 4; | ||
177 | } | ||
178 | |||
179 | this->hslist = getGlobalHighscores(); | ||
180 | |||
181 | if (this->hslist.empty()) | ||
182 | { | ||
183 | printf("Global Highscore List cannot be empty after adding a score to it.\n"); | ||
184 | throw 5; | ||
185 | } | ||
186 | |||
187 | if (rank > 10) | ||
188 | { | ||
189 | Highscore temph(hsname, level); | ||
190 | temph.setRank(rank); | ||
191 | |||
192 | this->hslist[9] = temph; | ||
193 | this->newpos = 10; | ||
194 | } else { | ||
195 | std::vector<Highscore>::iterator it; | ||
196 | bool found = false; | ||
197 | |||
198 | for (it=this->hslist.begin(); it<this->hslist.end(); it++) | ||
199 | { | ||
200 | Highscore h = *it; | ||
201 | |||
202 | if (!found) | ||
203 | { | ||
204 | if ((strcmp(h.getName(),hsname) == 0) && (h.getLevel() == level)) | ||
205 | { | ||
206 | this->newpos = h.getRank(); | ||
207 | found = true; | ||
208 | } | ||
209 | } | ||
210 | } | ||
211 | } | ||
212 | } catch (int e) | ||
213 | { | ||
214 | fail = true; | ||
215 | } | ||
216 | } | ||
217 | |||
218 | int SubmitHighscoreListState::SubmitHighscoreList::getNewPos() | ||
219 | { | ||
220 | return newpos; | ||
221 | } | ||
222 | |||
223 | bool SubmitHighscoreListState::SubmitHighscoreList::hasFailed() | ||
224 | { | ||
225 | return fail; | ||
226 | } | ||
diff --git a/hssubmit.h b/hssubmit.h deleted file mode 100644 index 243dab8..0000000 --- a/hssubmit.h +++ /dev/null | |||
@@ -1,34 +0,0 @@ | |||
1 | #ifndef HSSUBMIT_H | ||
2 | #define HSSUBMIT_H | ||
3 | |||
4 | class SubmitHighscoreListState : public State { | ||
5 | public: | ||
6 | SubmitHighscoreListState(char* hsname, int level); | ||
7 | void input(SDL_keysym key); | ||
8 | void render(SDL_Surface* screen); | ||
9 | |||
10 | private: | ||
11 | static int LoadHighscoreList(void* pParam); | ||
12 | |||
13 | class SubmitHighscoreList : public GlobalHighscoreList { | ||
14 | public: | ||
15 | SubmitHighscoreList(char* hsname, int level); | ||
16 | int getNewPos(); | ||
17 | bool hasFailed(); | ||
18 | |||
19 | private: | ||
20 | int newpos; | ||
21 | }; | ||
22 | |||
23 | SDL_Surface* list; | ||
24 | SDL_Surface* options; | ||
25 | SDL_Surface* pointer; | ||
26 | char* hsname; | ||
27 | int level; | ||
28 | bool scoreSent; | ||
29 | int selection; | ||
30 | int newpos; | ||
31 | bool fail; | ||
32 | }; | ||
33 | |||
34 | #endif | ||
diff --git a/htpstate.cpp b/htpstate.cpp deleted file mode 100644 index 0771290..0000000 --- a/htpstate.cpp +++ /dev/null | |||
@@ -1,57 +0,0 @@ | |||
1 | #include "includes.h" | ||
2 | |||
3 | HowToPlayState::HowToPlayState() | ||
4 | { | ||
5 | background1 = SDL_LoadBMP("resources/htp1.bmp"); | ||
6 | background2 = SDL_LoadBMP("resources/htp2.bmp"); | ||
7 | pointer = SDL_LoadBMP("resources/pointer.bmp"); | ||
8 | |||
9 | secondPage = false; | ||
10 | selection = 0; | ||
11 | } | ||
12 | |||
13 | void HowToPlayState::input(SDL_keysym key) | ||
14 | { | ||
15 | if ((key.sym == SDLK_LEFT) && (selection != 0)) | ||
16 | { | ||
17 | selection--; | ||
18 | } else if ((key.sym == SDLK_RIGHT) && (selection != 1)) | ||
19 | { | ||
20 | selection++; | ||
21 | } else if (key.sym == SDLK_RETURN) | ||
22 | { | ||
23 | switch (selection) | ||
24 | { | ||
25 | case 0: | ||
26 | secondPage = !secondPage; | ||
27 | |||
28 | break; | ||
29 | case 1: | ||
30 | changeState(new TitleState()); | ||
31 | |||
32 | break; | ||
33 | } | ||
34 | } | ||
35 | } | ||
36 | |||
37 | void HowToPlayState::render(SDL_Surface* screen) | ||
38 | { | ||
39 | SDL_Rect pSpace; | ||
40 | |||
41 | if (!secondPage) | ||
42 | { | ||
43 | SDL_BlitSurface(background1, NULL, screen, NULL); | ||
44 | |||
45 | pSpace.x = (selection==0?74:216); | ||
46 | } else { | ||
47 | SDL_BlitSurface(background2, NULL, screen, NULL); | ||
48 | |||
49 | pSpace.x = (selection==0?45:238); | ||
50 | } | ||
51 | |||
52 | pSpace.y = 430; | ||
53 | pSpace.w = pointer->w; | ||
54 | pSpace.h = pointer->h; | ||
55 | |||
56 | SDL_BlitSurface(pointer, NULL, screen, &pSpace); | ||
57 | } | ||
diff --git a/htpstate.h b/htpstate.h deleted file mode 100644 index 79c66ba..0000000 --- a/htpstate.h +++ /dev/null | |||
@@ -1,18 +0,0 @@ | |||
1 | #ifndef HTPSTATE_H | ||
2 | #define HTPSTATE_H | ||
3 | |||
4 | class HowToPlayState : public State { | ||
5 | public: | ||
6 | HowToPlayState(); | ||
7 | void input(SDL_keysym key); | ||
8 | void render(SDL_Surface* screen); | ||
9 | |||
10 | private: | ||
11 | SDL_Surface* background1; | ||
12 | SDL_Surface* background2; | ||
13 | SDL_Surface* pointer; | ||
14 | bool secondPage; | ||
15 | int selection; | ||
16 | }; | ||
17 | |||
18 | #endif | ||
diff --git a/icon.ico b/icon.ico deleted file mode 100644 index 37e9db6..0000000 --- a/icon.ico +++ /dev/null | |||
Binary files differ | |||
diff --git a/includes.h b/includes.h deleted file mode 100644 index 38523b7..0000000 --- a/includes.h +++ /dev/null | |||
@@ -1,23 +0,0 @@ | |||
1 | #include <SDL.h> | ||
2 | #include <SDL/SDL_ttf.h> | ||
3 | #include <SDL/SDL_net.h> | ||
4 | #include <SDL_thread.h> | ||
5 | #include <stdio.h> | ||
6 | #include <time.h> | ||
7 | #include <string> | ||
8 | #include <vector> | ||
9 | #include <fstream> | ||
10 | #include <sstream> | ||
11 | #include <exception> | ||
12 | #include "state.h" | ||
13 | #include "mazeoflife.h" | ||
14 | #include "titlestate.h" | ||
15 | #include "htpstate.h" | ||
16 | #include "chlstate.h" | ||
17 | #include "gamestate.h" | ||
18 | #include "highscore.h" | ||
19 | #include "hslist.h" | ||
20 | #include "hslocal.h" | ||
21 | #include "hsnew.h" | ||
22 | #include "hsglobal.h" | ||
23 | #include "hssubmit.h" | ||
diff --git a/mazeoflife.cpp b/mazeoflife.cpp index 107a640..a020f6c 100644 --- a/mazeoflife.cpp +++ b/mazeoflife.cpp | |||
@@ -1,7 +1,12 @@ | |||
1 | #include "includes.h" | 1 | #include "mazeoflife.h" |
2 | 2 | #include <SDL.h> | |
3 | SDL_Surface *screen; | 3 | #include <SDL_ttf.h> |
4 | State* state; | 4 | #include <SDL_net.h> |
5 | #include <cstdlib> | ||
6 | #include <ctime> | ||
7 | #include <iostream> | ||
8 | #include "state.h" | ||
9 | #include "titlestate.h" | ||
5 | 10 | ||
6 | int main(int argc, char *argv[]) | 11 | int main(int argc, char *argv[]) |
7 | { | 12 | { |
@@ -24,118 +29,30 @@ int main(int argc, char *argv[]) | |||
24 | printf("Cound not initalize SDL_net: %s.\n", SDLNet_GetError()); | 29 | printf("Cound not initalize SDL_net: %s.\n", SDLNet_GetError()); |
25 | exit(-1); | 30 | exit(-1); |
26 | } | 31 | } |
27 | 32 | ||
28 | /* Clean up on exit */ | 33 | SDL_Window* window = SDL_CreateWindow("Maze of Life", 100, 100, 480, 480, SDL_WINDOW_SHOWN); |
29 | atexit(SDL_Quit); | 34 | if (window == NULL) |
30 | atexit(TTF_Quit); | ||
31 | atexit(SDLNet_Quit); | ||
32 | |||
33 | SDL_WM_SetCaption("Maze Of Life", NULL); | ||
34 | |||
35 | SDL_Surface* icon; | ||
36 | icon = SDL_LoadBMP("resources/icon.bmp"); | ||
37 | SDL_WM_SetIcon(icon, NULL); | ||
38 | |||
39 | /* | ||
40 | * Initialize the display in a 640x480 8-bit palettized mode, | ||
41 | * requesting a software surface | ||
42 | */ | ||
43 | screen = SDL_SetVideoMode(WIDTH*16, HEIGHT*16, 8, SDL_DOUBLEBUF); | ||
44 | if ( screen == NULL ) { | ||
45 | fprintf(stderr, "Couldn't set %dx%dx8 video mode: %s\n", WIDTH*16, WIDTH*16, SDL_GetError()); | ||
46 | exit(1); | ||
47 | } | ||
48 | |||
49 | SDL_EnableKeyRepeat(100, 70); | ||
50 | |||
51 | state = new TitleState(); | ||
52 | |||
53 | SDL_AddTimer(TICKDELAY, *tick, NULL); | ||
54 | |||
55 | SDL_Event anEvent; | ||
56 | for (;;) | ||
57 | { | 35 | { |
58 | while (SDL_PollEvent(&anEvent)) | 36 | std::cout << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl; |
59 | { | 37 | return 1; |
60 | switch (anEvent.type) | ||
61 | { | ||
62 | case SDL_QUIT: | ||
63 | exit(0); | ||
64 | |||
65 | break; | ||
66 | case SDL_KEYDOWN: | ||
67 | if (anEvent.key.keysym.sym == SDLK_F4) | ||
68 | { | ||
69 | SDL_WM_ToggleFullScreen(screen); | ||
70 | } else { | ||
71 | state->input(anEvent.key.keysym); | ||
72 | } | ||
73 | |||
74 | break; | ||
75 | } | ||
76 | } | ||
77 | } | 38 | } |
78 | 39 | ||
79 | exit(0); | 40 | SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC); |
80 | } | 41 | if (renderer == NULL) |
81 | |||
82 | void wrap(int* x, int* y) | ||
83 | { | ||
84 | if (*x < 0) | ||
85 | { | ||
86 | *x = WIDTH-(0-*x); | ||
87 | } else if (*y < 0) | ||
88 | { | 42 | { |
89 | *y = HEIGHT-(0-*y); | 43 | std::cout << "SDL_CreateRenderer Error: " << SDL_GetError() << std::endl; |
90 | } else if (*x >= WIDTH) | 44 | return 1; |
91 | { | ||
92 | *x = *x-WIDTH; | ||
93 | } else if (*y >= HEIGHT) | ||
94 | { | ||
95 | *y = *y-HEIGHT; | ||
96 | } | 45 | } |
97 | } | ||
98 | |||
99 | Uint32 getColor(int r, int g, int b) | ||
100 | { | ||
101 | return SDL_MapRGB(screen->format, r, g, b); | ||
102 | } | ||
103 | |||
104 | void changeState(State* nState) | ||
105 | { | ||
106 | state = nState; | ||
107 | } | ||
108 | |||
109 | Uint32 tick(Uint32 interval, void *param) | ||
110 | { | ||
111 | state->tick(); | ||
112 | state->render(screen); | ||
113 | 46 | ||
114 | SDL_Flip(screen); | 47 | State* state = new TitleState(); |
115 | 48 | while (state != NULL) | |
116 | return interval; | ||
117 | } | ||
118 | |||
119 | TTF_Font* loadFont(int size) | ||
120 | { | ||
121 | TTF_Font* tmpfont = TTF_OpenFont("resources/mono.ttf", size); | ||
122 | |||
123 | if (tmpfont == NULL) | ||
124 | { | 49 | { |
125 | printf("Unable to load font: %s\n", TTF_GetError()); | 50 | state = (*state)(renderer); |
126 | exit(1); | ||
127 | } | 51 | } |
128 | 52 | ||
129 | return tmpfont; | 53 | SDL_DestroyRenderer(renderer); |
130 | } | 54 | SDL_DestroyWindow(window); |
131 | 55 | SDLNet_Quit(); | |
132 | const char* getDataFile() | 56 | TTF_Quit(); |
133 | { | 57 | SDL_Quit(); |
134 | #ifdef WINDOWS | 58 | } \ No newline at end of file |
135 | char* dir = getenv("USERPROFILE"); | ||
136 | #else | ||
137 | char* dir = getenv("HOME"); | ||
138 | #endif | ||
139 | |||
140 | return (std::string(dir) + "/.molhslist").c_str(); | ||
141 | } | ||
diff --git a/mazeoflife.h b/mazeoflife.h index 00a31cf..3cc6d6d 100644 --- a/mazeoflife.h +++ b/mazeoflife.h | |||
@@ -3,13 +3,5 @@ | |||
3 | 3 | ||
4 | const int WIDTH = 30; | 4 | const int WIDTH = 30; |
5 | const int HEIGHT = 30; | 5 | const int HEIGHT = 30; |
6 | const int TICKDELAY = 5; | ||
7 | |||
8 | void wrap(int* x, int* y); | ||
9 | Uint32 getColor(int r, int g, int b); | ||
10 | void changeState(State* nState); | ||
11 | Uint32 tick(Uint32 interval, void *param); | ||
12 | TTF_Font* loadFont(int size); | ||
13 | const char* getDataFile(); | ||
14 | 6 | ||
15 | #endif | 7 | #endif |
diff --git a/state.h b/state.h index 7373940..2d6f804 100644 --- a/state.h +++ b/state.h | |||
@@ -1,12 +1,12 @@ | |||
1 | #include <SDL.h> | ||
2 | |||
1 | #ifndef STATE_H | 3 | #ifndef STATE_H |
2 | #define STATE_H | 4 | #define STATE_H |
3 | 5 | ||
4 | class State | 6 | class State |
5 | { | 7 | { |
6 | public: | 8 | public: |
7 | virtual void input(SDL_keysym key) {}; | 9 | virtual State* operator() (SDL_Renderer* renderer) {return NULL;}; |
8 | virtual void tick() {}; | ||
9 | virtual void render(SDL_Surface* screen) {}; | ||
10 | }; | 10 | }; |
11 | 11 | ||
12 | #endif | 12 | #endif \ No newline at end of file |
diff --git a/titlestate.cpp b/titlestate.cpp index 5a9b91e..8375c4a 100644 --- a/titlestate.cpp +++ b/titlestate.cpp | |||
@@ -1,52 +1,44 @@ | |||
1 | #include "includes.h" | 1 | #include "titlestate.h" |
2 | #include "util.h" | ||
2 | 3 | ||
3 | TitleState::TitleState() | 4 | State* TitleState::operator() (SDL_Renderer* renderer) |
4 | { | 5 | { |
5 | background = SDL_LoadBMP("resources/title.bmp"); | 6 | SDL_Texture* background = loadImage(renderer, "resources/title.bmp"); |
6 | pointer = SDL_LoadBMP("resources/pointer.bmp"); | 7 | SDL_Texture* pointer = loadImage(renderer, "resources/pointer.bmp"); |
7 | 8 | int selection = 0; | |
8 | selection = 0; | 9 | SDL_Event e; |
9 | } | 10 | |
10 | 11 | for (;;) | |
11 | void TitleState::input(SDL_keysym key) | ||
12 | { | ||
13 | if ((key.sym == SDLK_UP) && (selection != 0)) | ||
14 | { | 12 | { |
15 | selection--; | 13 | while (SDL_PollEvent(&e)) |
16 | } else if ((key.sym == SDLK_DOWN) && (selection != 3)) | ||
17 | { | ||
18 | selection++; | ||
19 | } else if (key.sym == SDLK_RETURN) | ||
20 | { | ||
21 | switch (selection) | ||
22 | { | 14 | { |
23 | case 0: | 15 | if (e.type == SDL_QUIT) |
24 | changeState(new GameState()); | 16 | { |
25 | 17 | return NULL; | |
26 | break; | 18 | } else if (e.type == SDL_KEYDOWN) |
27 | case 1: | 19 | { |
28 | changeState(new HowToPlayState()); | 20 | if ((e.key.keysym.sym == SDLK_UP) && (selection != 0)) |
29 | 21 | { | |
30 | break; | 22 | selection--; |
31 | case 2: | 23 | } else if ((e.key.keysym.sym == SDLK_DOWN) && (selection != 3)) |
32 | changeState(new ChooseHighscoreListState()); | 24 | { |
33 | 25 | selection++; | |
34 | break; | 26 | } else if (e.key.keysym.sym == SDLK_RETURN) |
35 | case 3: | 27 | { |
36 | exit(0); | 28 | switch (selection) |
29 | { | ||
30 | //case 0: return new GameState(); | ||
31 | //case 1: return new HowToPlayState(); | ||
32 | //case 2: return new ChooseHighscoreListState(); | ||
33 | case 3: return NULL; | ||
34 | } | ||
35 | } | ||
36 | } | ||
37 | } | 37 | } |
38 | |||
39 | SDL_RenderClear(renderer); | ||
40 | SDL_RenderCopy(renderer, background, NULL, NULL); | ||
41 | applyTexture(renderer, pointer, 136, selection==0?316:(selection==1?350:(selection==2?381:417))); | ||
42 | SDL_RenderPresent(renderer); | ||
38 | } | 43 | } |
39 | } | 44 | } \ No newline at end of file |
40 | |||
41 | void TitleState::render(SDL_Surface* screen) | ||
42 | { | ||
43 | SDL_BlitSurface(background, NULL, screen, NULL); | ||
44 | |||
45 | SDL_Rect pSpace; | ||
46 | pSpace.x = 136; | ||
47 | pSpace.y = (selection==0?316:(selection==1?350:(selection==2?381:417))); | ||
48 | pSpace.w = pointer->w; | ||
49 | pSpace.h = pointer->h; | ||
50 | |||
51 | SDL_BlitSurface(pointer, NULL, screen, &pSpace); | ||
52 | } | ||
diff --git a/titlestate.h b/titlestate.h index 6519ecf..11d16d7 100644 --- a/titlestate.h +++ b/titlestate.h | |||
@@ -1,16 +1,12 @@ | |||
1 | #include <SDL.h> | ||
2 | #include "state.h" | ||
3 | |||
1 | #ifndef TITLESTATE_H | 4 | #ifndef TITLESTATE_H |
2 | #define TITLESTATE_H | 5 | #define TITLESTATE_H |
3 | 6 | ||
4 | class TitleState : public State { | 7 | class TitleState : public State { |
5 | public: | 8 | public: |
6 | TitleState(); | 9 | State* operator() (SDL_Renderer* renderer); |
7 | void input(SDL_keysym key); | ||
8 | void render(SDL_Surface* screen); | ||
9 | |||
10 | private: | ||
11 | SDL_Surface* background; | ||
12 | SDL_Surface* pointer; | ||
13 | int selection; | ||
14 | }; | 10 | }; |
15 | 11 | ||
16 | #endif | 12 | #endif \ No newline at end of file |
diff --git a/util.cpp b/util.cpp new file mode 100644 index 0000000..b021146 --- /dev/null +++ b/util.cpp | |||
@@ -0,0 +1,69 @@ | |||
1 | #include "util.h" | ||
2 | #include "mazeoflife.h" | ||
3 | #include <iostream> | ||
4 | |||
5 | void wrap(int* x, int* y) | ||
6 | { | ||
7 | if (*x < 0) | ||
8 | { | ||
9 | *x = WIDTH-(0-*x); | ||
10 | } else if (*y < 0) | ||
11 | { | ||
12 | *y = HEIGHT-(0-*y); | ||
13 | } else if (*x >= WIDTH) | ||
14 | { | ||
15 | *x = *x-WIDTH; | ||
16 | } else if (*y >= HEIGHT) | ||
17 | { | ||
18 | *y = *y-HEIGHT; | ||
19 | } | ||
20 | } | ||
21 | |||
22 | TTF_Font* loadFont(int size) | ||
23 | { | ||
24 | TTF_Font* tmpfont = TTF_OpenFont("resources/mono.ttf", size); | ||
25 | |||
26 | if (tmpfont == NULL) | ||
27 | { | ||
28 | printf("Unable to load font: %s\n", TTF_GetError()); | ||
29 | exit(1); | ||
30 | } | ||
31 | |||
32 | return tmpfont; | ||
33 | } | ||
34 | |||
35 | const char* getDataFile() | ||
36 | { | ||
37 | #ifdef WINDOWS | ||
38 | char* dir = getenv("USERPROFILE"); | ||
39 | #else | ||
40 | char* dir = getenv("HOME"); | ||
41 | #endif | ||
42 | |||
43 | return (std::string(dir) + "/.molhslist").c_str(); | ||
44 | } | ||
45 | |||
46 | SDL_Texture* loadImage(SDL_Renderer* renderer, std::string file) | ||
47 | { | ||
48 | SDL_Surface* surface = SDL_LoadBMP(file.c_str()); | ||
49 | if (surface == NULL) | ||
50 | { | ||
51 | std::cout << SDL_GetError() << std::endl; | ||
52 | return NULL; | ||
53 | } | ||
54 | |||
55 | SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surface); | ||
56 | SDL_FreeSurface(surface); | ||
57 | |||
58 | return texture; | ||
59 | } | ||
60 | |||
61 | void applyTexture(SDL_Renderer* renderer, SDL_Texture* tex, int x, int y) | ||
62 | { | ||
63 | SDL_Rect pos; | ||
64 | pos.x = x; | ||
65 | pos.y = y; | ||
66 | SDL_QueryTexture(tex, NULL, NULL, &pos.w, &pos.h); | ||
67 | |||
68 | SDL_RenderCopy(renderer, tex, NULL, &pos); | ||
69 | } \ No newline at end of file | ||
diff --git a/util.h b/util.h new file mode 100644 index 0000000..365a759 --- /dev/null +++ b/util.h | |||
@@ -0,0 +1,14 @@ | |||
1 | #include <SDL.h> | ||
2 | #include <SDL_ttf.h> | ||
3 | #include <string> | ||
4 | |||
5 | #ifndef UTIL_H | ||
6 | #define UTIL_H | ||
7 | |||
8 | void wrap(int* x, int* y); | ||
9 | TTF_Font* loadFont(int size); | ||
10 | const char* getDataFile(); | ||
11 | SDL_Texture* loadImage(SDL_Renderer* renderer, std::string file); | ||
12 | void applyTexture(SDL_Renderer* renderer, SDL_Texture* tex, int x, int y); | ||
13 | |||
14 | #endif \ No newline at end of file | ||
diff --git a/winres.rc b/winres.rc deleted file mode 100644 index 1bc463a..0000000 --- a/winres.rc +++ /dev/null | |||
@@ -1 +0,0 @@ | |||
1 | IDI_ICON1 ICON DISCARDABLE "icon.ico" | ||