+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2004 Michael George <mike@georgetech.com>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#include <cstdlib>
-#include <string>
-
-#include "configfile.h"
-#include "setup.h"
-#include "globals.h"
-#include "lispreader.h"
-#include "player.h"
-
-#ifdef WIN32
-const char * config_filename = "/st_config.dat";
-#else
-const char * config_filename = "/config";
-#endif
-
-static void defaults ()
-{
- /* Set defaults: */
- debug_mode = false;
- audio_device = true;
-
- use_fullscreen = false;
- show_fps = false;
- use_gl = false;
-
- use_sound = true;
- use_music = true;
-}
-
-void loadconfig(void)
-{
- FILE * file = NULL;
-
- defaults();
-
- /* override defaults from config file */
-
- file = opendata(config_filename, "r");
-
- if (file == NULL)
- return;
-
- /* read config file */
-
- lisp_stream_t stream;
- lisp_object_t * root_obj = NULL;
-
- lisp_stream_init_file (&stream, file);
- root_obj = lisp_read (&stream);
-
- if (root_obj->type == LISP_TYPE_EOF || root_obj->type == LISP_TYPE_PARSE_ERROR)
- return;
-
- if (strcmp(lisp_symbol(lisp_car(root_obj)), "supertux-config") != 0)
- return;
-
- LispReader reader(lisp_cdr(root_obj));
-
- reader.read_bool("fullscreen", use_fullscreen);
- reader.read_bool("sound", use_sound);
- reader.read_bool("music", use_music);
- reader.read_bool("show_fps", show_fps);
-
- std::string video;
- reader.read_string ("video", video);
- if (video == "opengl")
- use_gl = true;
- else
- use_gl = false;
-
- reader.read_int ("joystick", joystick_num);
-
- if (joystick_num >= 0)
- {
- reader.read_int ("joystick-x", joystick_keymap.x_axis);
- reader.read_int ("joystick-y", joystick_keymap.y_axis);
- reader.read_int ("joystick-a", joystick_keymap.a_button);
- reader.read_int ("joystick-b", joystick_keymap.b_button);
- reader.read_int ("joystick-start", joystick_keymap.start_button);
- reader.read_int ("joystick-deadzone", joystick_keymap.dead_zone);
- }
-
- reader.read_int ("keyboard-jump", keymap.jump);
- reader.read_int ("keyboard-activate", keymap.activate);
- reader.read_int ("keyboard-duck", keymap.duck);
- reader.read_int ("keyboard-left", keymap.left);
- reader.read_int ("keyboard-right", keymap.right);
- reader.read_int ("keyboard-fire", keymap.fire);
-
- lisp_free(root_obj);
-}
-
-void saveconfig (void)
-{
- /* write settings to config file */
- FILE * config = opendata(config_filename, "w");
-
- if(config)
- {
- fprintf(config, "(supertux-config\n");
- fprintf(config, "\t;; the following options can be set to #t or #f:\n");
- fprintf(config, "\t(fullscreen %s)\n", use_fullscreen ? "#t" : "#f");
- fprintf(config, "\t(sound %s)\n", use_sound ? "#t" : "#f");
- fprintf(config, "\t(music %s)\n", use_music ? "#t" : "#f");
- fprintf(config, "\t(show_fps %s)\n", show_fps ? "#t" : "#f");
-
- fprintf(config, "\n\t;; either \"opengl\" or \"sdl\"\n");
- fprintf(config, "\t(video \"%s\")\n", use_gl ? "opengl" : "sdl");
-
- if(use_joystick)
- {
- fprintf(config, "\n\t;; joystick number:\n");
- fprintf(config, "\t(joystick %d)\n", joystick_num);
-
- fprintf(config, "\t(joystick-x %d)\n", joystick_keymap.x_axis);
- fprintf(config, "\t(joystick-y %d)\n", joystick_keymap.y_axis);
- fprintf(config, "\t(joystick-a %d)\n", joystick_keymap.a_button);
- fprintf(config, "\t(joystick-b %d)\n", joystick_keymap.b_button);
- fprintf(config, "\t(joystick-start %d)\n", joystick_keymap.start_button);
- fprintf(config, "\t(joystick-deadzone %d)\n", joystick_keymap.dead_zone);
- }
-
- fprintf(config, "\t(keyboard-jump %d)\n", keymap.jump);
- fprintf(config, "\t(keyboard-duck %d)\n", keymap.duck);
- fprintf(config, "\t(keyboard-left %d)\n", keymap.left);
- fprintf(config, "\t(keyboard-right %d)\n", keymap.right);
- fprintf(config, "\t(keyboard-fire %d)\n", keymap.fire);
- fprintf(config, "\t(keyboard-activate %d)\n", keymap.activate);
-
- fprintf(config, ")\n");
- }
-}
-
-/* EOF */
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2004 Michael George <mike@georgetech.com>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#ifndef SUPERTUX_CONFIGFILE_H
-#define SUPERTUX_CONFIGFILE_H
-
-void loadconfig (void);
-void saveconfig (void);
-
-#endif
-
-/* Local Variables: */
-/* mode:c++ */
-/* End: */
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2003 Tobias Glaesser <tobi.web@gmx.de>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#ifndef SUPERTUX_EXCEPTIONS_H
-#define SUPERTUX_EXCEPTIONS_H
-
-// Exceptions
-#include <exception>
-#include <string>
-
-class SuperTuxException : public std::exception
-{
- public:
- SuperTuxException(const char* _message, const char* _file = "", const unsigned int _line = 0)
- : message(_message), file(_file), line(_line) { };
- virtual ~SuperTuxException() throw() { };
-
- const char* what() const throw() { return message; };
- const char* what_file() const throw() { return file; };
- const unsigned int what_line() const throw() { return line; };
-
- private:
- const char* message;
- const char* file;
- const unsigned int line;
-};
-
-#endif /*SUPERTUX_EXCEPTIONS_H*/
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2004 Matthias Braun <matze@braunis.de
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#include "game_object.h"
-
-GameObject::GameObject()
- : wants_to_die(false)
-{
-}
-
-GameObject::~GameObject()
-{
-}
-
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2004 Matthias Braun <matze@braunis.de
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#ifndef SUPERTUX_GAMEOBJECT_H
-#define SUPERTUX_GAMEOBJECT_H
-
-#include <string>
-
-class DrawingContext;
-
-/**
- * Base class for all game objects. This contains functions for:
- * -querying the actual type of the object
- * -a flag that indicates if the object wants to be removed. Objects with this
- * flag will be removed at the end of each frame. This is alot safer than
- * having some uncontrollable "delete this" in the code.
- * -an action function that is called once per frame and allows the object to
- * update it's state.
- *
- * Most GameObjects will also implement the DrawableObject interface so that
- * they can actually be drawn on screen.
- */
-class GameObject // TODO rename this once the game has been converted
-{
-public:
- GameObject();
- virtual ~GameObject();
-
- /** This function is called once per frame and allows the object to update
- * it's state. The elapsed_time is the time since the last frame and should be
- * the base for all timed things.
- */
- virtual void action(float elapsed_time) = 0;
-
- /** The GameObject should draw itself onto the provided DrawingContext if this
- * function is called.
- */
- virtual void draw(DrawingContext& context) = 0;
-
- /** returns true if the object is not scheduled to be removed yet */
- bool is_valid() const
- { return !wants_to_die; }
- /** schedules this object to be removed at the end of the frame */
- void remove_me()
- { wants_to_die = true; }
-
-private:
- /** this flag indicates if the object should be removed at the end of the
- * frame
- */
- bool wants_to_die;
-};
-
-#endif /*SUPERTUX_GAMEOBJECT_H*/
-
+++ /dev/null
-/* Convenience header for conditional use of GNU <libintl.h>.
- Copyright (C) 1995-1998, 2000-2002 Free Software Foundation, Inc.
-
- This program is free software; you can redistribute it and/or modify it
- under the terms of the GNU Library General Public License as published
- by the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Library General Public License for more details.
-
- You should have received a copy of the GNU Library General Public
- License along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
- USA. */
-
-#ifndef _LIBGETTEXT_H
-#define _LIBGETTEXT_H 1
-
-#ifdef HAVE_GETTEXT
-# define _(String) gettext(String)
-# define N_(String) gettext_noop(String)
-#else
-# define _(String) String
-# define N_(String) String
-#endif
-
-/* NLS can be disabled through the configure --disable-nls option. */
-#if ENABLE_NLS
-
-/* Get declarations of GNU message catalog functions. */
-# include <libintl.h>
-
-#else
-
-/* Solaris /usr/include/locale.h includes /usr/include/libintl.h, which
- chokes if dcgettext is defined as a macro. So include it now, to make
- later inclusions of <locale.h> a NOP. We don't include <libintl.h>
- as well because people using "gettext.h" will not include <libintl.h>,
- and also including <libintl.h> would fail on SunOS 4, whereas <locale.h>
- is OK. */
-#if defined(__sun)
-# include <locale.h>
-#endif
-
-/* Disabled NLS.
- The casts to 'const char *' serve the purpose of producing warnings
- for invalid uses of the value returned from these functions.
- On pre-ANSI systems without 'const', the config.h file is supposed to
- contain "#define const". */
-# define gettext(Msgid) ((const char *) (Msgid))
-# define dgettext(Domainname, Msgid) ((const char *) (Msgid))
-# define dcgettext(Domainname, Msgid, Category) ((const char *) (Msgid))
-# define ngettext(Msgid1, Msgid2, N) \
- ((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2))
-# define dngettext(Domainname, Msgid1, Msgid2, N) \
- ((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2))
-# define dcngettext(Domainname, Msgid1, Msgid2, N, Category) \
- ((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2))
-# define textdomain(Domainname) ((const char *) (Domainname))
-# define bindtextdomain(Domainname, Dirname) ((const char *) (Dirname))
-# define bind_textdomain_codeset(Domainname, Codeset) ((const char *) (Codeset))
-
-#endif
-
-/* A pseudo function call that serves as a marker for the automated
- extraction of messages, but does not call gettext(). The run-time
- translation is done at a different place in the code.
- The argument, String, should be a literal string. Concatenated strings
- and other string expressions won't work.
- The macro's expansion is not parenthesized, so that it is suitable as
- initializer for static 'char[]' or 'const char[]' variables. */
-#define gettext_noop(String) String
-
-#endif /* _LIBGETTEXT_H */
+++ /dev/null
-// $Id$
-//
-// SuperTux
-// Copyright (C) 2004 SuperTux Development Team, see AUTHORS for details
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-// 02111-1307, USA.
-
-#include "globals.h"
-
-/** The datadir prefix prepended when loading game data file */
-std::string datadir;
-
-JoystickKeymap::JoystickKeymap()
-{
- a_button = 0;
- b_button = 1;
- start_button = 2;
-
- x_axis = 0;
- y_axis = 1;
-
- dead_zone = 4096;
-}
-
-JoystickKeymap joystick_keymap;
-
-SDL_Surface * screen;
-Font* gold_text;
-Font* blue_text;
-Font* gray_text;
-Font* yellow_nums;
-Font* white_text;
-Font* white_small_text;
-Font* white_big_text;
-
-MouseCursor * mouse_cursor;
-
-bool use_gl;
-bool use_joystick;
-bool use_fullscreen;
-bool debug_mode;
-bool show_fps;
-float game_speed = 1.0f;
-
-int joystick_num = 0;
-char* level_startup_file = 0;
-bool launch_leveleditor_mode = false;
-bool launch_worldmap_mode = false;
-
-/* SuperTux directory ($HOME/.supertux) and save directory($HOME/.supertux/save) */
-char *st_dir, *st_save_dir;
-
-SDL_Joystick * js;
-
-/* Returns 1 for every button event, 2 for a quit event and 0 for no event. */
-int wait_for_event(SDL_Event& event,unsigned int min_delay, unsigned int max_delay, bool empty_events)
-{
- int i;
- Timer maxdelay;
- Timer mindelay;
-
- maxdelay.init(false);
- mindelay.init(false);
-
- if(max_delay < min_delay)
- max_delay = min_delay;
-
- maxdelay.start(max_delay);
- mindelay.start(min_delay);
-
- if(empty_events)
- while (SDL_PollEvent(&event))
- {}
-
- /* Handle events: */
-
- for(i = 0; maxdelay.check() || !i; ++i)
- {
- while (SDL_PollEvent(&event))
- {
- if(!mindelay.check())
- {
- if (event.type == SDL_QUIT)
- {
- /* Quit event - quit: */
- return 2;
- }
- else if (event.type == SDL_KEYDOWN)
- {
- /* Keypress - skip intro: */
-
- return 1;
- }
- else if (event.type == SDL_JOYBUTTONDOWN)
- {
- /* Fire button - skip intro: */
-
- return 1;
- }
- else if (event.type == SDL_MOUSEBUTTONDOWN)
- {
- /* Mouse button - skip intro: */
- return 1;
- }
- }
- }
- SDL_Delay(10);
- }
-
- return 0;
-}
+++ /dev/null
-// $Id$
-//
-// SuperTux
-// Copyright (C) 2004 Bill Kendrick <bill@newbreedsoftware.com>
-// Tobias Glaesser <tobi.web@gmx.de>
-// Ingo Ruhnke <grumbel@gmx.de>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#ifndef SUPERTUX_GLOBALS_H
-#define SUPERTUX_GLOBALS_H
-
-#include <string>
-
-#include "SDL.h"
-
-#include "screen/font.h"
-#include "menu.h"
-#include "mousecursor.h"
-
-extern std::string datadir;
-
-struct JoystickKeymap
-{
- int a_button;
- int b_button;
- int start_button;
-
- int x_axis;
- int y_axis;
-
- int dead_zone;
-
- JoystickKeymap();
-};
-
-extern JoystickKeymap joystick_keymap;
-
-extern SDL_Surface* screen;
-extern Font* gold_text;
-extern Font* white_text;
-extern Font* blue_text;
-extern Font* gray_text;
-extern Font* white_small_text;
-extern Font* white_big_text;
-extern Font* yellow_nums;
-
-extern MouseCursor * mouse_cursor;
-
-extern bool use_gl;
-extern bool use_joystick;
-extern bool use_fullscreen;
-extern bool debug_mode;
-extern bool show_fps;
-
-/** The number of the joystick that will be use in the game */
-extern int joystick_num;
-extern char* level_startup_file;
-extern bool launch_leveleditor_mode;
-extern bool launch_worldmap_mode;
-
-/* SuperTux directory ($HOME/.supertux) and save directory($HOME/.supertux/save) */
-extern char* st_dir;
-extern char* st_save_dir;
-
-extern float game_speed;
-extern SDL_Joystick * js;
-
-int wait_for_event(SDL_Event& event,unsigned int min_delay = 0, unsigned int max_delay = 0, bool empty_events = false);
-
-#endif /* SUPERTUX_GLOBALS_H */
+++ /dev/null
-/* $Id$ */
-/*
- * lispreader.c
- *
- * Copyright (C) 1998-2000 Mark Probst
- * Copyright (C) 2002 Ingo Ruhnke <grumbel@gmx.de>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-#include <iostream>
-#include <vector>
-#include <string>
-#include <cctype>
-#include <cstdlib>
-#include <cstring>
-
-#include "setup.h"
-#include "lispreader.h"
-
-#define TOKEN_ERROR -1
-#define TOKEN_EOF 0
-#define TOKEN_OPEN_PAREN 1
-#define TOKEN_CLOSE_PAREN 2
-#define TOKEN_SYMBOL 3
-#define TOKEN_STRING 4
-#define TOKEN_INTEGER 5
-#define TOKEN_REAL 6
-#define TOKEN_PATTERN_OPEN_PAREN 7
-#define TOKEN_DOT 8
-#define TOKEN_TRUE 9
-#define TOKEN_FALSE 10
-
-
-#define MAX_TOKEN_LENGTH 4096
-
-static char token_string[MAX_TOKEN_LENGTH + 1] = "";
-static int token_length = 0;
-
-static lisp_object_t end_marker = { LISP_TYPE_EOF, {{0, 0}} };
-static lisp_object_t error_object = { LISP_TYPE_PARSE_ERROR , {{0,0}} };
-static lisp_object_t close_paren_marker = { LISP_TYPE_PARSE_ERROR , {{0,0}} };
-static lisp_object_t dot_marker = { LISP_TYPE_PARSE_ERROR , {{0,0}} };
-
-static void
-_token_clear (void)
-{
- token_string[0] = '\0';
- token_length = 0;
-}
-
-static void
-_token_append (char c)
-{
- if (token_length >= MAX_TOKEN_LENGTH)
- throw LispReaderException("_token_append()", __FILE__, __LINE__);
-
- token_string[token_length++] = c;
- token_string[token_length] = '\0';
-}
-
-static int
-_next_char (lisp_stream_t *stream)
-{
- switch (stream->type)
- {
- case LISP_STREAM_FILE :
- return getc(stream->v.file);
-
- case LISP_STREAM_STRING :
- {
- char c = stream->v.string.buf[stream->v.string.pos];
-
- if (c == 0)
- return EOF;
-
- ++stream->v.string.pos;
-
- return c;
- }
-
- case LISP_STREAM_ANY:
- return stream->v.any.next_char(stream->v.any.data);
- }
-
- throw LispReaderException("_next_char()", __FILE__, __LINE__);
- return EOF;
-}
-
-static void
-_unget_char (char c, lisp_stream_t *stream)
-{
- switch (stream->type)
- {
- case LISP_STREAM_FILE :
- ungetc(c, stream->v.file);
- break;
-
- case LISP_STREAM_STRING :
- --stream->v.string.pos;
- break;
-
- case LISP_STREAM_ANY:
- stream->v.any.unget_char(c, stream->v.any.data);
- break;
-
- default :
- throw LispReaderException("_unget_char()", __FILE__, __LINE__);
- }
-}
-
-static int
-_scan (lisp_stream_t *stream)
-{
- static char *delims = "\"();";
-
- int c;
-
- _token_clear();
-
- do
- {
- c = _next_char(stream);
- if (c == EOF)
- return TOKEN_EOF;
- else if (c == ';') /* comment start */
- while (1)
- {
- c = _next_char(stream);
- if (c == EOF)
- return TOKEN_EOF;
- else if (c == '\n')
- break;
- }
- }
- while (isspace(c));
-
- switch (c)
- {
- case '(' :
- return TOKEN_OPEN_PAREN;
-
- case ')' :
- return TOKEN_CLOSE_PAREN;
-
- case '"' :
- while (1)
- {
- c = _next_char(stream);
- if (c == EOF)
- return TOKEN_ERROR;
- if (c == '"')
- break;
- if (c == '\\')
- {
- c = _next_char(stream);
-
- switch (c)
- {
- case EOF :
- return TOKEN_ERROR;
-
- case 'n' :
- c = '\n';
- break;
-
- case 't' :
- c = '\t';
- break;
- }
- }
-
- _token_append(c);
- }
- return TOKEN_STRING;
-
- case '#' :
- c = _next_char(stream);
- if (c == EOF)
- return TOKEN_ERROR;
-
- switch (c)
- {
- case 't' :
- return TOKEN_TRUE;
-
- case 'f' :
- return TOKEN_FALSE;
-
- case '?' :
- c = _next_char(stream);
- if (c == EOF)
- return TOKEN_ERROR;
-
- if (c == '(')
- return TOKEN_PATTERN_OPEN_PAREN;
- else
- return TOKEN_ERROR;
- }
- return TOKEN_ERROR;
-
- default :
- if (isdigit(c) || c == '-')
- {
- int have_nondigits = 0;
- int have_digits = 0;
- int have_floating_point = 0;
-
- do
- {
- if (isdigit(c))
- have_digits = 1;
- else if (c == '.')
- have_floating_point++;
- _token_append(c);
-
- c = _next_char(stream);
-
- if (c != EOF && !isdigit(c) && !isspace(c) && c != '.' && !strchr(delims, c))
- have_nondigits = 1;
- }
- while (c != EOF && !isspace(c) && !strchr(delims, c));
-
- if (c != EOF)
- _unget_char(c, stream);
-
- if (have_nondigits || !have_digits || have_floating_point > 1)
- return TOKEN_SYMBOL;
- else if (have_floating_point == 1)
- return TOKEN_REAL;
- else
- return TOKEN_INTEGER;
- }
- else
- {
- if (c == '.')
- {
- c = _next_char(stream);
- if (c != EOF && !isspace(c) && !strchr(delims, c))
- _token_append('.');
- else
- {
- _unget_char(c, stream);
- return TOKEN_DOT;
- }
- }
- do
- {
- _token_append(c);
- c = _next_char(stream);
- }
- while (c != EOF && !isspace(c) && !strchr(delims, c));
- if (c != EOF)
- _unget_char(c, stream);
-
- return TOKEN_SYMBOL;
- }
- }
-
- throw LispReaderException("_scan()", __FILE__, __LINE__);
- return TOKEN_ERROR;
-}
-
-static lisp_object_t*
-lisp_object_alloc (int type)
-{
- lisp_object_t *obj = (lisp_object_t*)malloc(sizeof(lisp_object_t));
-
- obj->type = type;
-
- return obj;
-}
-
-lisp_stream_t*
-lisp_stream_init_file (lisp_stream_t *stream, FILE *file)
-{
- stream->type = LISP_STREAM_FILE;
- stream->v.file = file;
-
- return stream;
-}
-
-lisp_stream_t*
-lisp_stream_init_string (lisp_stream_t *stream, char *buf)
-{
- stream->type = LISP_STREAM_STRING;
- stream->v.string.buf = buf;
- stream->v.string.pos = 0;
-
- return stream;
-}
-
-lisp_stream_t*
-lisp_stream_init_any (lisp_stream_t *stream, void *data,
- int (*next_char) (void *data),
- void (*unget_char) (char c, void *data))
-{
- if (next_char == 0 || unget_char == 0)
- throw LispReaderException("lisp_stream_init_any()", __FILE__, __LINE__);
-
- stream->type = LISP_STREAM_ANY;
- stream->v.any.data = data;
- stream->v.any.next_char= next_char;
- stream->v.any.unget_char = unget_char;
-
- return stream;
-}
-
-lisp_object_t*
-lisp_make_integer (int value)
-{
- lisp_object_t *obj = lisp_object_alloc(LISP_TYPE_INTEGER);
-
- obj->v.integer = value;
-
- return obj;
-}
-
-lisp_object_t*
-lisp_make_real (float value)
-{
- lisp_object_t *obj = lisp_object_alloc(LISP_TYPE_REAL);
-
- obj->v.real = value;
-
- return obj;
-}
-
-lisp_object_t*
-lisp_make_symbol (const char *value)
-{
- lisp_object_t *obj = lisp_object_alloc(LISP_TYPE_SYMBOL);
-
- obj->v.string = strdup(value);
-
- return obj;
-}
-
-lisp_object_t*
-lisp_make_string (const char *value)
-{
- lisp_object_t *obj = lisp_object_alloc(LISP_TYPE_STRING);
-
- obj->v.string = strdup(value);
-
- return obj;
-}
-
-lisp_object_t*
-lisp_make_cons (lisp_object_t *car, lisp_object_t *cdr)
-{
- lisp_object_t *obj = lisp_object_alloc(LISP_TYPE_CONS);
-
- obj->v.cons.car = car;
- obj->v.cons.cdr = cdr;
-
- return obj;
-}
-
-lisp_object_t*
-lisp_make_boolean (int value)
-{
- lisp_object_t *obj = lisp_object_alloc(LISP_TYPE_BOOLEAN);
-
- obj->v.integer = value ? 1 : 0;
-
- return obj;
-}
-
-static lisp_object_t*
-lisp_make_pattern_cons (lisp_object_t *car, lisp_object_t *cdr)
-{
- lisp_object_t *obj = lisp_object_alloc(LISP_TYPE_PATTERN_CONS);
-
- obj->v.cons.car = car;
- obj->v.cons.cdr = cdr;
-
- return obj;
-}
-
-static lisp_object_t*
-lisp_make_pattern_var (int type, int index, lisp_object_t *sub)
-{
- lisp_object_t *obj = lisp_object_alloc(LISP_TYPE_PATTERN_VAR);
-
- obj->v.pattern.type = type;
- obj->v.pattern.index = index;
- obj->v.pattern.sub = sub;
-
- return obj;
-}
-
-lisp_object_t*
-lisp_read (lisp_stream_t *in)
-{
- int token = _scan(in);
- lisp_object_t *obj = lisp_nil();
-
- if (token == TOKEN_EOF)
- return &end_marker;
-
- switch (token)
- {
- case TOKEN_ERROR :
- return &error_object;
-
- case TOKEN_EOF :
- return &end_marker;
-
- case TOKEN_OPEN_PAREN :
- case TOKEN_PATTERN_OPEN_PAREN :
- {
- lisp_object_t *last = lisp_nil(), *car;
-
- do
- {
- car = lisp_read(in);
- if (car == &error_object || car == &end_marker)
- {
- lisp_free(obj);
- return &error_object;
- }
- else if (car == &dot_marker)
- {
- if (lisp_nil_p(last))
- {
- lisp_free(obj);
- return &error_object;
- }
-
- car = lisp_read(in);
- if (car == &error_object || car == &end_marker)
- {
- lisp_free(obj);
- return car;
- }
- else
- {
- last->v.cons.cdr = car;
-
- if (_scan(in) != TOKEN_CLOSE_PAREN)
- {
- lisp_free(obj);
- return &error_object;
- }
-
- car = &close_paren_marker;
- }
- }
- else if (car != &close_paren_marker)
- {
- if (lisp_nil_p(last))
- obj = last = (token == TOKEN_OPEN_PAREN ? lisp_make_cons(car, lisp_nil()) : lisp_make_pattern_cons(car, lisp_nil()));
- else
- last = last->v.cons.cdr = lisp_make_cons(car, lisp_nil());
- }
- }
- while (car != &close_paren_marker);
- }
- return obj;
-
- case TOKEN_CLOSE_PAREN :
- return &close_paren_marker;
-
- case TOKEN_SYMBOL :
- return lisp_make_symbol(token_string);
-
- case TOKEN_STRING :
- return lisp_make_string(token_string);
-
- case TOKEN_INTEGER :
- return lisp_make_integer(atoi(token_string));
-
- case TOKEN_REAL :
- return lisp_make_real((float)atof(token_string));
-
- case TOKEN_DOT :
- return &dot_marker;
-
- case TOKEN_TRUE :
- return lisp_make_boolean(1);
-
- case TOKEN_FALSE :
- return lisp_make_boolean(0);
- }
-
- throw LispReaderException("lisp_read()", __FILE__, __LINE__);
- return &error_object;
-}
-
-void
-lisp_free (lisp_object_t *obj)
-{
- if (obj == 0)
- return;
-
- /** We have to use this iterative code, because the recursive function
- * produces a stack overflow and crashs on OSX 10.2
- */
- std::vector<lisp_object_t*> objs;
- objs.push_back(obj);
-
- while(!objs.empty()) {
- lisp_object_t* obj = objs.back();
- objs.pop_back();
-
- switch (obj->type) {
- case LISP_TYPE_INTERNAL :
- case LISP_TYPE_PARSE_ERROR :
- case LISP_TYPE_EOF :
- return;
-
- case LISP_TYPE_SYMBOL :
- case LISP_TYPE_STRING :
- free(obj->v.string);
- break;
-
- case LISP_TYPE_CONS :
- case LISP_TYPE_PATTERN_CONS :
- if(obj->v.cons.car)
- objs.push_back(obj->v.cons.car);
- if(obj->v.cons.cdr)
- objs.push_back(obj->v.cons.cdr);
- break;
-
- case LISP_TYPE_PATTERN_VAR :
- if(obj->v.pattern.sub)
- objs.push_back(obj->v.pattern.sub);
- break;
- }
-
- free(obj);
- }
-}
-
-lisp_object_t*
-lisp_read_from_string (const char *buf)
-{
- lisp_stream_t stream;
-
- lisp_stream_init_string(&stream, (char*)buf);
- return lisp_read(&stream);
-}
-
-static int
-_compile_pattern (lisp_object_t **obj, int *index)
-{
- if (*obj == 0)
- return 1;
-
- switch (lisp_type(*obj))
- {
- case LISP_TYPE_PATTERN_CONS :
- {
- struct
- {
- char *name;
- int type;
- }
- types[] =
- {
- { "any", LISP_PATTERN_ANY },
- { "symbol", LISP_PATTERN_SYMBOL },
- { "string", LISP_PATTERN_STRING },
- { "integer", LISP_PATTERN_INTEGER },
- { "real", LISP_PATTERN_REAL },
- { "boolean", LISP_PATTERN_BOOLEAN },
- { "list", LISP_PATTERN_LIST },
- { "or", LISP_PATTERN_OR },
- { 0, 0 }
- };
- char *type_name;
- int type;
- int i;
- lisp_object_t *pattern;
- type = -1;
-
- if (lisp_type(lisp_car(*obj)) != LISP_TYPE_SYMBOL)
- return 0;
-
- type_name = lisp_symbol(lisp_car(*obj));
- for (i = 0; types[i].name != 0; ++i)
- {
- if (strcmp(types[i].name, type_name) == 0)
- {
- type = types[i].type;
- break;
- }
- }
-
- if (types[i].name == 0)
- return 0;
-
- if (type != LISP_PATTERN_OR && lisp_cdr(*obj) != 0)
- return 0;
-
- pattern = lisp_make_pattern_var(type, (*index)++, lisp_nil());
-
- if (type == LISP_PATTERN_OR)
- {
- lisp_object_t *cdr = lisp_cdr(*obj);
-
- if (!_compile_pattern(&cdr, index))
- {
- lisp_free(pattern);
- return 0;
- }
-
- pattern->v.pattern.sub = cdr;
-
- (*obj)->v.cons.cdr = lisp_nil();
- }
-
- lisp_free(*obj);
-
- *obj = pattern;
- }
- break;
-
- case LISP_TYPE_CONS :
- if (!_compile_pattern(&(*obj)->v.cons.car, index))
- return 0;
- if (!_compile_pattern(&(*obj)->v.cons.cdr, index))
- return 0;
- break;
- }
-
- return 1;
-}
-
-int
-lisp_compile_pattern (lisp_object_t **obj, int *num_subs)
-{
- int index = 0;
- int result;
-
- result = _compile_pattern(obj, &index);
-
- if (result && num_subs != 0)
- *num_subs = index;
-
- return result;
-}
-
-static int _match_pattern (lisp_object_t *pattern, lisp_object_t *obj, lisp_object_t **vars);
-
-static int
-_match_pattern_var (lisp_object_t *pattern, lisp_object_t *obj, lisp_object_t **vars)
-{
- if (lisp_type(pattern) != LISP_TYPE_PATTERN_VAR)
- throw LispReaderException("_match_pattern_var", __FILE__, __LINE__);
-
- switch (pattern->v.pattern.type)
- {
- case LISP_PATTERN_ANY :
- break;
-
- case LISP_PATTERN_SYMBOL :
- if (obj == 0 || lisp_type(obj) != LISP_TYPE_SYMBOL)
- return 0;
- break;
-
- case LISP_PATTERN_STRING :
- if (obj == 0 || lisp_type(obj) != LISP_TYPE_STRING)
- return 0;
- break;
-
- case LISP_PATTERN_INTEGER :
- if (obj == 0 || lisp_type(obj) != LISP_TYPE_INTEGER)
- return 0;
- break;
-
- case LISP_PATTERN_REAL :
- if (obj == 0 || lisp_type(obj) != LISP_TYPE_REAL)
- return 0;
- break;
-
- case LISP_PATTERN_BOOLEAN :
- if (obj == 0 || lisp_type(obj) != LISP_TYPE_BOOLEAN)
- return 0;
- break;
-
- case LISP_PATTERN_LIST :
- if (obj == 0 || lisp_type(obj) != LISP_TYPE_CONS)
- return 0;
- break;
-
- case LISP_PATTERN_OR :
- {
- lisp_object_t *sub;
- int matched = 0;
-
- for (sub = pattern->v.pattern.sub; sub != 0; sub = lisp_cdr(sub))
- {
- if (lisp_type(sub) != LISP_TYPE_CONS)
- throw LispReaderException("_match_pattern_var()", __FILE__, __LINE__);
-
- if (_match_pattern(lisp_car(sub), obj, vars))
- matched = 1;
- }
-
- if (!matched)
- return 0;
- }
- break;
-
- default :
- throw LispReaderException("_match_pattern_var()", __FILE__, __LINE__);
- }
-
- if (vars != 0)
- vars[pattern->v.pattern.index] = obj;
-
- return 1;
-}
-
-static int
-_match_pattern (lisp_object_t *pattern, lisp_object_t *obj, lisp_object_t **vars)
-{
- if (pattern == 0)
- return obj == 0;
-
- if (obj == 0)
- return 0;
-
- if (lisp_type(pattern) == LISP_TYPE_PATTERN_VAR)
- return _match_pattern_var(pattern, obj, vars);
-
- if (lisp_type(pattern) != lisp_type(obj))
- return 0;
-
- switch (lisp_type(pattern))
- {
- case LISP_TYPE_SYMBOL :
- return strcmp(lisp_symbol(pattern), lisp_symbol(obj)) == 0;
-
- case LISP_TYPE_STRING :
- return strcmp(lisp_string(pattern), lisp_string(obj)) == 0;
-
- case LISP_TYPE_INTEGER :
- return lisp_integer(pattern) == lisp_integer(obj);
-
- case LISP_TYPE_REAL :
- return lisp_real(pattern) == lisp_real(obj);
-
- case LISP_TYPE_CONS :
- {
- int result1, result2;
-
- result1 = _match_pattern(lisp_car(pattern), lisp_car(obj), vars);
- result2 = _match_pattern(lisp_cdr(pattern), lisp_cdr(obj), vars);
-
- return result1 && result2;
- }
- break;
-
- default :
- throw LispReaderException("_match_pattern()", __FILE__, __LINE__);
- }
-
- return 0;
-}
-
-int
-lisp_match_pattern (lisp_object_t *pattern, lisp_object_t *obj, lisp_object_t **vars, int num_subs)
-{
- int i;
-
- if (vars != 0)
- for (i = 0; i < num_subs; ++i)
- vars[i] = &error_object;
-
- return _match_pattern(pattern, obj, vars);
-}
-
-int
-lisp_match_string (const char *pattern_string, lisp_object_t *obj, lisp_object_t **vars)
-{
- lisp_object_t *pattern;
- int result;
- int num_subs;
-
- pattern = lisp_read_from_string(pattern_string);
-
- if (pattern != 0 && (lisp_type(pattern) == LISP_TYPE_EOF
- || lisp_type(pattern) == LISP_TYPE_PARSE_ERROR))
- return 0;
-
- if (!lisp_compile_pattern(&pattern, &num_subs))
- {
- lisp_free(pattern);
- return 0;
- }
-
- result = lisp_match_pattern(pattern, obj, vars, num_subs);
-
- lisp_free(pattern);
-
- return result;
-}
-
-int
-lisp_type (lisp_object_t *obj)
-{
- if (obj == 0)
- return LISP_TYPE_NIL;
- return obj->type;
-}
-
-int
-lisp_integer (lisp_object_t *obj)
-{
- if (obj->type != LISP_TYPE_INTEGER)
- throw LispReaderException("lisp_integer()", __FILE__, __LINE__);
-
- return obj->v.integer;
-}
-
-char*
-lisp_symbol (lisp_object_t *obj)
-{
- if (obj->type != LISP_TYPE_SYMBOL)
- throw LispReaderException("lisp_symbol()", __FILE__, __LINE__);
-
- return obj->v.string;
-}
-
-char*
-lisp_string (lisp_object_t *obj)
-{
- if (obj->type != LISP_TYPE_STRING)
- throw LispReaderException("lisp_string()", __FILE__, __LINE__);
-
- return obj->v.string;
-}
-
-int
-lisp_boolean (lisp_object_t *obj)
-{
- if (obj->type != LISP_TYPE_BOOLEAN)
- throw LispReaderException("lisp_boolean()", __FILE__, __LINE__);
-
- return obj->v.integer;
-}
-
-float
-lisp_real (lisp_object_t *obj)
-{
- if (obj->type != LISP_TYPE_REAL && obj->type != LISP_TYPE_INTEGER)
- throw LispReaderException("lisp_real()", __FILE__, __LINE__);
-
- if (obj->type == LISP_TYPE_INTEGER)
- return obj->v.integer;
- return obj->v.real;
-}
-
-lisp_object_t*
-lisp_car (lisp_object_t *obj)
-{
- if (obj->type != LISP_TYPE_CONS && obj->type != LISP_TYPE_PATTERN_CONS)
- throw LispReaderException("lisp_car()", __FILE__, __LINE__);
-
- return obj->v.cons.car;
-}
-
-lisp_object_t*
-lisp_cdr (lisp_object_t *obj)
-{
- if (obj->type != LISP_TYPE_CONS && obj->type != LISP_TYPE_PATTERN_CONS)
- throw LispReaderException("lisp_cdr()", __FILE__, __LINE__);
-
- return obj->v.cons.cdr;
-}
-
-lisp_object_t*
-lisp_cxr (lisp_object_t *obj, const char *x)
-{
- int i;
-
- for (i = strlen(x) - 1; i >= 0; --i)
- if (x[i] == 'a')
- obj = lisp_car(obj);
- else if (x[i] == 'd')
- obj = lisp_cdr(obj);
- else
- throw LispReaderException("lisp_cxr()", __FILE__, __LINE__);
-
- return obj;
-}
-
-int
-lisp_list_length (lisp_object_t *obj)
-{
- int length = 0;
-
- while (obj != 0)
- {
- if (obj->type != LISP_TYPE_CONS && obj->type != LISP_TYPE_PATTERN_CONS)
- throw LispReaderException("lisp_list_length()", __FILE__, __LINE__);
-
- ++length;
- obj = obj->v.cons.cdr;
- }
-
- return length;
-}
-
-lisp_object_t*
-lisp_list_nth_cdr (lisp_object_t *obj, int index)
-{
- while (index > 0)
- {
- if (obj == 0)
- throw LispReaderException("lisp_list_nth_cdr()", __FILE__, __LINE__);
- if (obj->type != LISP_TYPE_CONS && obj->type != LISP_TYPE_PATTERN_CONS)
- throw LispReaderException("lisp_list_nth_cdr()", __FILE__, __LINE__);
-
- --index;
- obj = obj->v.cons.cdr;
- }
-
- return obj;
-}
-
-lisp_object_t*
-lisp_list_nth (lisp_object_t *obj, int index)
-{
- obj = lisp_list_nth_cdr(obj, index);
-
- if (obj == 0)
- throw LispReaderException("lisp_list_nth()", __FILE__, __LINE__);
-
- return obj->v.cons.car;
-}
-
-void
-lisp_dump (lisp_object_t *obj, FILE *out)
-{
- if (obj == 0)
- {
- fprintf(out, "()");
- return;
- }
-
- switch (lisp_type(obj))
- {
- case LISP_TYPE_EOF :
- fputs("#<eof>", out);
- break;
-
- case LISP_TYPE_PARSE_ERROR :
- fputs("#<error>", out);
- break;
-
- case LISP_TYPE_INTEGER :
- fprintf(out, "%d", lisp_integer(obj));
- break;
-
- case LISP_TYPE_REAL :
- fprintf(out, "%f", lisp_real(obj));
- break;
-
- case LISP_TYPE_SYMBOL :
- fputs(lisp_symbol(obj), out);
- break;
-
- case LISP_TYPE_STRING :
- {
- char *p;
-
- fputc('"', out);
- for (p = lisp_string(obj); *p != 0; ++p)
- {
- if (*p == '"' || *p == '\\')
- fputc('\\', out);
- fputc(*p, out);
- }
- fputc('"', out);
- }
- break;
-
- case LISP_TYPE_CONS :
- case LISP_TYPE_PATTERN_CONS :
- fputs(lisp_type(obj) == LISP_TYPE_CONS ? "(" : "#?(", out);
- while (obj != 0)
- {
- lisp_dump(lisp_car(obj), out);
- obj = lisp_cdr(obj);
- if (obj != 0)
- {
- if (lisp_type(obj) != LISP_TYPE_CONS
- && lisp_type(obj) != LISP_TYPE_PATTERN_CONS)
- {
- fputs(" . ", out);
- lisp_dump(obj, out);
- break;
- }
- else
- fputc(' ', out);
- }
- }
- fputc(')', out);
- break;
-
- case LISP_TYPE_BOOLEAN :
- if (lisp_boolean(obj))
- fputs("#t", out);
- else
- fputs("#f", out);
- break;
-
- default :
- throw LispReaderException("lisp_dump()", __FILE__, __LINE__);
- }
-}
-
-using namespace std;
-
-LispReader::LispReader (lisp_object_t* l)
- : owner(0), lst (l)
-{
-}
-
-LispReader::~LispReader()
-{
- if(owner)
- lisp_free(owner);
-}
-
-LispReader*
-LispReader::load(const std::string& filename, const std::string& toplevellist)
-{
- lisp_object_t* obj = lisp_read_from_file(filename);
-
- if(obj->type == LISP_TYPE_EOF || obj->type == LISP_TYPE_PARSE_ERROR) {
- lisp_free(obj);
- throw LispReaderException("LispReader::load", __FILE__, __LINE__);
- }
-
- if(toplevellist != lisp_symbol(lisp_car(obj))) {
- lisp_car(obj);
- throw LispReaderException("LispReader::load wrong toplevel symbol",
- __FILE__, __LINE__);
- }
-
- LispReader* reader = new LispReader(lisp_cdr(obj));
- reader->owner = obj;
-
- return reader;
-}
-
-lisp_object_t*
-LispReader::search_for(const char* name)
-{
- //std::cout << "LispReader::search_for(" << name << ")" << std::endl;
- lisp_object_t* cursor = lst;
-
- while(!lisp_nil_p(cursor))
- {
- lisp_object_t* cur = lisp_car(cursor);
-
- if (!lisp_cons_p(cur) || !lisp_symbol_p (lisp_car(cur)))
- {
- lisp_dump(cur, stdout);
- //throw ConstruoError (std::string("LispReader: Read error in search_for ") + name);
- printf("LispReader: Read error in search\n");
- }
- else
- {
- if (strcmp(lisp_symbol(lisp_car(cur)), name) == 0)
- {
- return lisp_cdr(cur);
- }
- }
-
- cursor = lisp_cdr (cursor);
- }
- return 0;
-}
-
-bool
-LispReader::read_int (const char* name, int& i)
-{
- lisp_object_t* obj = search_for (name);
- if(!obj)
- return false;
-
- if (!lisp_integer_p(lisp_car(obj)))
- return false;
-
- i = lisp_integer(lisp_car(obj));
- return true;
-}
-
-bool
-LispReader::read_lisp(const char* name, lisp_object_t*& b)
-{
- lisp_object_t* obj = search_for (name);
- if (!obj)
- return false;
-
- b = obj;
- return true;
-}
-
-lisp_object_t*
-LispReader::read_lisp(const char* name)
-{
- return search_for(name);
-}
-
-bool
-LispReader::read_float (const char* name, float& f)
-{
- lisp_object_t* obj = search_for (name);
- if (!obj)
- return false;
-
- if (!lisp_real_p(lisp_car(obj)) && !lisp_integer_p(lisp_car(obj)))
- st_abort("LispReader expected type real at token: ", name);
-
- f = lisp_real(lisp_car(obj));
- return true;
-}
-
-bool
-LispReader::read_string_vector (const char* name, std::vector<std::string>& vec)
-{
- lisp_object_t* obj = search_for (name);
- if (!obj)
- return false;
-
- vec.clear();
- while(!lisp_nil_p(obj))
- {
- if (!lisp_string_p(lisp_car(obj)))
- st_abort("LispReader expected type string at token: ", name);
- vec.push_back(lisp_string(lisp_car(obj)));
- obj = lisp_cdr(obj);
- }
- return true;
-}
-
-bool
-LispReader::read_int_vector (const char* name, std::vector<int>& vec)
-{
- lisp_object_t* obj = search_for (name);
- if (!obj)
- return false;
-
- vec.clear();
- while(!lisp_nil_p(obj))
- {
- if (!lisp_integer_p(lisp_car(obj)))
- st_abort("LispReader expected type integer at token: ", name);
- vec.push_back(lisp_integer(lisp_car(obj)));
- obj = lisp_cdr(obj);
- }
- return true;
-}
-
-bool
-LispReader::read_int_vector (const char* name, std::vector<unsigned int>& vec)
-{
- lisp_object_t* obj = search_for (name);
- if (!obj)
- return false;
-
- vec.clear();
- while(!lisp_nil_p(obj))
- {
- if (!lisp_integer_p(lisp_car(obj)))
- st_abort("LispReader expected type integer at token: ", name);
- vec.push_back(lisp_integer(lisp_car(obj)));
- obj = lisp_cdr(obj);
- }
- return true;
-}
-
-bool
-LispReader::read_char_vector (const char* name, std::vector<char>& vec)
-{
- lisp_object_t* obj = search_for (name);
- if (!obj)
- return false;
-
- vec.clear();
- while(!lisp_nil_p(obj))
- {
- vec.push_back(*lisp_string(lisp_car(obj)));
- obj = lisp_cdr(obj);
- }
- return true;
-}
-
-bool
-LispReader::read_string (const char* name, std::string& str, bool translatable)
-{
- lisp_object_t* obj;
- if(translatable)
- {
- /* Internationalization support: check for the suffix: str + "-" + $LANG variable.
- If not found, use the regular string.
- So, translating a string in a Lisp file would result in something like:
- (text "Hello World!")
- (text-fr "Bonjour Monde!")
- being fr the value of LANG (echo $LANG) for the language we want to translate to */
-
- char* lang = getenv("LANG");
-
- char str_[1024]; // check, for instance, for (title-fr_FR "Bonjour")
-
- if(lang != NULL && strlen(lang) >= 5)
- {
- char lang_[6];
- strncpy(lang_, lang, 5);
- lang_[5] = '\0';
- sprintf(str_, "%s-%s", name, lang_);
-
- obj = search_for (str_);
- }
- else
- obj = 0;
-
- if(!obj) // check, for instance, for (title-fr "Bonjour")
- {
- if(lang != NULL && strlen(lang) >= 2)
- {
- char lang_[3];
- strncpy(lang_, lang, 2);
- lang_[2] = '\0';
- sprintf(str_, "%s-%s", name, lang_);
-
- obj = search_for (str_);
- }
- else
- obj = 0;
- }
-
- if(!obj) // check, for instance, for (title "Hello")
- obj = search_for (name);
- }
- else
- obj = search_for (name);
-
- if (!obj)
- return false;
-
- if (!lisp_string_p(lisp_car(obj)))
- st_abort("LispReader expected type string at token: ", name);
- str = lisp_string(lisp_car(obj));
- return true;
-}
-
-bool
-LispReader::read_bool (const char* name, bool& b)
-{
- lisp_object_t* obj = search_for (name);
- if (!obj)
- return false;
-
- if (!lisp_boolean_p(lisp_car(obj)))
- st_abort("LispReader expected type bool at token: ", name);
- b = lisp_boolean(lisp_car(obj));
- return true;
-}
-
-lisp_object_t*
-LispReader::get_lisp()
-{
- return lst;
-}
-
-lisp_object_t* lisp_read_from_file(const std::string& filename)
-{
- FILE* in = fopen(filename.c_str(), "r");
-
- if(!in)
- return 0;
-
- lisp_stream_t stream;
- lisp_stream_init_file(&stream, in);
- lisp_object_t* obj = lisp_read(&stream);
- fclose(in);
-
- return obj;
-}
-
-// EOF //
+++ /dev/null
-/* $Id$ */
-/*
- * lispreader.h
- *
- * Copyright (C) 1998-2000 Mark Probst
- * Copyright (C) 2002 Ingo Ruhnke <grumbel@gmx.de>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- */
-
-#ifndef SUPERTUX_LISPREADER_H
-#define SUPERTUX_LISPREADER_H
-
-#include <cstdio>
-#include <string>
-#include <vector>
-#include <exception>
-
-#include <zlib.h>
-
-#include "exceptions.h"
-
-#define LISP_STREAM_FILE 1
-#define LISP_STREAM_STRING 2
-#define LISP_STREAM_ANY 3
-
-#define LISP_TYPE_INTERNAL -3
-#define LISP_TYPE_PARSE_ERROR -2
-#define LISP_TYPE_EOF -1
-#define LISP_TYPE_NIL 0
-#define LISP_TYPE_SYMBOL 1
-#define LISP_TYPE_INTEGER 2
-#define LISP_TYPE_STRING 3
-#define LISP_TYPE_REAL 4
-#define LISP_TYPE_CONS 5
-#define LISP_TYPE_PATTERN_CONS 6
-#define LISP_TYPE_BOOLEAN 7
-#define LISP_TYPE_PATTERN_VAR 8
-
-#define LISP_PATTERN_ANY 1
-#define LISP_PATTERN_SYMBOL 2
-#define LISP_PATTERN_STRING 3
-#define LISP_PATTERN_INTEGER 4
-#define LISP_PATTERN_REAL 5
-#define LISP_PATTERN_BOOLEAN 6
-#define LISP_PATTERN_LIST 7
-#define LISP_PATTERN_OR 8
-
-// Exception
-class LispReaderException : public SuperTuxException
-{
- public:
- LispReaderException(const char* _message = "lispreader error", const char* _file = "", const unsigned int _line = 0)
- : SuperTuxException(_message, _file, _line) { };
-};
-
-typedef struct
- {
- int type;
-
- union
- {
- FILE *file;
- struct
- {
- char *buf;
- int pos;
- }
- string;
- struct
- {
- void *data;
- int (*next_char) (void *data);
- void (*unget_char) (char c, void *data);
- }
- any;
- } v;
- }
-lisp_stream_t;
-
-typedef struct _lisp_object_t lisp_object_t;
-struct _lisp_object_t
- {
- int type;
-
- union
- {
- struct
- {
- struct _lisp_object_t *car;
- struct _lisp_object_t *cdr;
- }
- cons;
-
- char *string;
- int integer;
- float real;
-
- struct
- {
- int type;
- int index;
- struct _lisp_object_t *sub;
- }
- pattern;
- } v;
- };
-
-lisp_stream_t* lisp_stream_init_file (lisp_stream_t *stream, FILE *file);
-lisp_stream_t* lisp_stream_init_string (lisp_stream_t *stream, char *buf);
-lisp_stream_t* lisp_stream_init_any (lisp_stream_t *stream, void *data,
- int (*next_char) (void *data),
- void (*unget_char) (char c, void *data));
-
-lisp_object_t* lisp_read (lisp_stream_t *in);
-lisp_object_t* lisp_read_from_file(const std::string& filename);
-void lisp_free (lisp_object_t *obj);
-
-lisp_object_t* lisp_read_from_string (const char *buf);
-
-int lisp_compile_pattern (lisp_object_t **obj, int *num_subs);
-int lisp_match_pattern (lisp_object_t *pattern, lisp_object_t *obj, lisp_object_t **vars, int num_subs);
-int lisp_match_string (const char *pattern_string, lisp_object_t *obj, lisp_object_t **vars);
-
-int lisp_type (lisp_object_t *obj);
-int lisp_integer (lisp_object_t *obj);
-float lisp_real (lisp_object_t *obj);
-char* lisp_symbol (lisp_object_t *obj);
-char* lisp_string (lisp_object_t *obj);
-int lisp_boolean (lisp_object_t *obj);
-lisp_object_t* lisp_car (lisp_object_t *obj);
-lisp_object_t* lisp_cdr (lisp_object_t *obj);
-
-lisp_object_t* lisp_cxr (lisp_object_t *obj, const char *x);
-
-lisp_object_t* lisp_make_integer (int value);
-lisp_object_t* lisp_make_real (float value);
-lisp_object_t* lisp_make_symbol (const char *value);
-lisp_object_t* lisp_make_string (const char *value);
-lisp_object_t* lisp_make_cons (lisp_object_t *car, lisp_object_t *cdr);
-lisp_object_t* lisp_make_boolean (int value);
-
-int lisp_list_length (lisp_object_t *obj);
-lisp_object_t* lisp_list_nth_cdr (lisp_object_t *obj, int index);
-lisp_object_t* lisp_list_nth (lisp_object_t *obj, int index);
-
-void lisp_dump (lisp_object_t *obj, FILE *out);
-
-#define lisp_nil() ((lisp_object_t*)0)
-
-#define lisp_nil_p(obj) (obj == 0)
-#define lisp_integer_p(obj) (lisp_type((obj)) == LISP_TYPE_INTEGER)
-#define lisp_real_p(obj) (lisp_type((obj)) == LISP_TYPE_REAL)
-#define lisp_symbol_p(obj) (lisp_type((obj)) == LISP_TYPE_SYMBOL)
-#define lisp_string_p(obj) (lisp_type((obj)) == LISP_TYPE_STRING)
-#define lisp_cons_p(obj) (lisp_type((obj)) == LISP_TYPE_CONS)
-#define lisp_boolean_p(obj) (lisp_type((obj)) == LISP_TYPE_BOOLEAN)
-
-/** */
-class LispReader
-{
-private:
- lisp_object_t* owner;
- lisp_object_t* lst;
-
- lisp_object_t* search_for(const char* name);
-
-public:
- /** cur == ((pos 1 2 3) (id 12 3 4)...) */
- LispReader(lisp_object_t* l);
- ~LispReader();
-
- bool read_int_vector(const char* name, std::vector<int>& vec);
- bool read_int_vector(const char* name, std::vector<unsigned int>& vec);
- bool read_char_vector(const char* name, std::vector<char>& vec);
- bool read_string_vector(const char* name, std::vector<std::string>& vec);
- bool read_string(const char* name, std::string& str, bool translatable = false);
- bool read_int(const char* name, int& i);
- bool read_float(const char* name, float& f);
- bool read_bool(const char* name, bool& b);
- bool read_lisp(const char* name, lisp_object_t*& b);
- lisp_object_t* read_lisp(const char* name);
-
- static LispReader* load(const std::string& filename,
- const std::string& toplevellist);
-
- lisp_object_t* get_lisp();
-};
-
-#endif /*SUPERTUX_LISPREADER_H*/
-
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2004 Matthias Braun <matze@braunis.de
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#include <iostream>
-
-#include "lispwriter.h"
-
-LispWriter::LispWriter(std::ostream& newout)
- : out(newout), indent_depth(0)
-{
-}
-
-LispWriter::~LispWriter()
-{
- if(lists.size() > 0) {
- std::cerr << "Warning: Not all sections closed in lispwriter!\n";
- }
-}
-
-void
-LispWriter::write_comment(const std::string& comment)
-{
- out << "; " << comment << "\n";
-}
-
-void
-LispWriter::start_list(const std::string& listname)
-{
- indent();
- out << '(' << listname << '\n';
- indent_depth += 2;
-
- lists.push_back(listname);
-}
-
-void
-LispWriter::end_list(const std::string& listname)
-{
- if(lists.size() == 0) {
- std::cerr << "Trying to close list '" << listname
- << "', which is not open.\n";
- return;
- }
- if(lists.back() != listname) {
- std::cerr << "Warning: trying to close list '" << listname
- << "' while list '" << lists.back() << "' is open.\n";
- return;
- }
- lists.pop_back();
-
- indent_depth -= 2;
- indent();
- out << ")\n";
-}
-
-void
-LispWriter::write_int(const std::string& name, int value)
-{
- indent();
- out << '(' << name << ' ' << value << ")\n";
-}
-
-void
-LispWriter::write_float(const std::string& name, float value)
-{
- indent();
- out << '(' << name << ' ' << value << ")\n";
-}
-
-void
-LispWriter::write_string(const std::string& name, const std::string& value)
-{
- indent();
- out << '(' << name << " \"" << value << "\")\n";
-}
-
-void
-LispWriter::write_bool(const std::string& name, bool value)
-{
- indent();
- out << '(' << name << ' ' << (value ? "#t" : "#f") << ")\n";
-}
-
-void
-LispWriter::write_int_vector(const std::string& name,
- const std::vector<int>& value)
-{
- indent();
- out << '(' << name;
- for(std::vector<int>::const_iterator i = value.begin(); i != value.end(); ++i)
- out << " " << *i;
- out << ")\n";
-}
-
-void
-LispWriter::write_int_vector(const std::string& name,
- const std::vector<unsigned int>& value)
-{
- indent();
- out << '(' << name;
- for(std::vector<unsigned int>::const_iterator i = value.begin(); i != value.end(); ++i)
- out << " " << *i;
- out << ")\n";
-}
-
-void
-LispWriter::indent()
-{
- for(int i = 0; i<indent_depth; ++i)
- out << ' ';
-}
-
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2004 Matthias Braun <matze@braunis.de
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#ifndef SUPERTUX_LISPWRITER_H
-#define SUPERTUX_LISPWRITER_H
-
-#include <iostream>
-#include <string>
-#include <vector>
-
-class LispWriter
-{
-public:
- LispWriter(std::ostream& out);
- ~LispWriter();
-
- void write_comment(const std::string& comment);
-
- void start_list(const std::string& listname);
-
- void write_int(const std::string& name, int value);
- void write_float(const std::string& name, float value);
- void write_string(const std::string& name, const std::string& value);
- void write_bool(const std::string& name, bool value);
- void write_int_vector(const std::string& name, const std::vector<int>& value);
- void write_int_vector(const std::string& name, const std::vector<unsigned int>& value);
- // add more write-functions when needed...
-
- void end_list(const std::string& listname);
-
-private:
- void indent();
-
- std::ostream& out;
- int indent_depth;
- std::vector<std::string> lists;
-};
-
-#endif
-
+++ /dev/null
-// $Id$
-//
-// SuperTux
-// Copyright (C) 2004 Tobias Glaesser <tobi.web@gmx.de>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#ifndef WIN32
-#include <sys/types.h>
-#include <ctype.h>
-#endif
-
-#include <iostream>
-#include <sstream>
-#include <cstdlib>
-#include <cstdio>
-#include <string>
-#include <cassert>
-
-#include "defines.h"
-#include "globals.h"
-#include "menu.h"
-#include "screen/screen.h"
-#include "screen/drawing_context.h"
-#include "setup.h"
-#include "sound.h"
-#include "scene.h"
-#include "leveleditor.h"
-#include "timer.h"
-#include "high_scores.h"
-#include "gettext.h"
-
-#define FLICK_CURSOR_TIME 500
-
-Surface* checkbox;
-Surface* checkbox_checked;
-Surface* back;
-Surface* arrow_left;
-Surface* arrow_right;
-
-Menu* main_menu = 0;
-Menu* game_menu = 0;
-Menu* worldmap_menu = 0;
-Menu* options_menu = 0;
-Menu* options_keys_menu = 0;
-Menu* options_joystick_menu = 0;
-Menu* highscore_menu = 0;
-Menu* load_game_menu = 0;
-Menu* save_game_menu = 0;
-Menu* contrib_menu = 0;
-Menu* contrib_subset_menu = 0;
-
-std::vector<Menu*> Menu::last_menus;
-Menu* Menu::current_ = 0;
-
-/* just displays a Yes/No text that can be used to confirm stuff */
-bool confirm_dialog(Surface *background, std::string text)
-{
- //Surface* cap_screen = Surface::CaptureScreen();
-
- Menu* dialog = new Menu;
- dialog->additem(MN_DEACTIVE, text,0,0);
- dialog->additem(MN_HL,"",0,0);
- dialog->additem(MN_ACTION,_("Yes"),0,0,true);
- dialog->additem(MN_ACTION,_("No"),0,0,false);
- dialog->additem(MN_HL,"",0,0);
-
- Menu::set_current(dialog);
-
- DrawingContext context;
-
- while(true)
- {
- SDL_Event event;
-
- while (SDL_PollEvent(&event))
- {
- dialog->event(event);
- }
-
- if(background == NULL)
- context.draw_gradient(Color(200,240,220), Color(200,200,220), LAYER_BACKGROUND0);
- else
- context.draw_surface(background, Vector(0,0), LAYER_BACKGROUND0);
-
- dialog->draw(context);
- dialog->action();
-
- switch (dialog->check())
- {
- case true:
- //delete cap_screen;
- Menu::set_current(0);
- delete dialog;
- return true;
- break;
- case false:
- //delete cap_screen;
- Menu::set_current(0);
- delete dialog;
- return false;
- break;
- default:
- break;
- }
-
- mouse_cursor->draw(context);
- context.do_drawing();
- SDL_Delay(25);
- }
-
- return false;
-}
-
-void
-Menu::push_current(Menu* pmenu)
-{
- if (current_)
- last_menus.push_back(current_);
-
- current_ = pmenu;
- current_->effect.start(500);
-}
-
-void
-Menu::pop_current()
-{
- if (!last_menus.empty())
- {
- current_ = last_menus.back();
- current_->effect.start(500);
-
- last_menus.pop_back();
- }
- else
- {
- current_ = 0;
- }
-}
-
-void
-Menu::set_current(Menu* menu)
-{
- last_menus.clear();
-
- if (menu)
- menu->effect.start(500);
-
- current_ = menu;
-}
-
-/* Return a pointer to a new menu item */
-MenuItem*
-MenuItem::create(MenuItemKind kind_, const char *text_, int init_toggle_, Menu* target_menu_, int id, int* int_p_)
-{
- MenuItem *pnew_item = new MenuItem;
-
- pnew_item->kind = kind_;
- pnew_item->text = (char*) malloc(sizeof(char) * (strlen(text_) + 1));
- strcpy(pnew_item->text, text_);
-
- if(kind_ == MN_TOGGLE)
- pnew_item->toggled = init_toggle_;
- else
- pnew_item->toggled = false;
-
- pnew_item->target_menu = target_menu_;
- pnew_item->input = (char*) malloc(sizeof(char));
- pnew_item->input[0] = '\0';
-
- if(kind_ == MN_STRINGSELECT)
- {
- pnew_item->list = (string_list_type*) malloc(sizeof(string_list_type));
- string_list_init(pnew_item->list);
- }
- else
- pnew_item->list = NULL;
-
- pnew_item->id = id;
- pnew_item->int_p = int_p_;
-
- pnew_item->input_flickering = false;
- pnew_item->input_flickering_timer.init(true);
- pnew_item->input_flickering_timer.start(FLICK_CURSOR_TIME);
-
- return pnew_item;
-}
-
-void
-MenuItem::change_text(const char *text_)
-{
- if (text_)
- {
- free(text);
- text = (char*) malloc(sizeof(char )*(strlen(text_)+1));
- strcpy(text, text_);
- }
-}
-
-void
-MenuItem::change_input(const char *text_)
-{
- if(text)
- {
- free(input);
- input = (char*) malloc(sizeof(char )*(strlen(text_)+1));
- strcpy(input, text_);
- }
-}
-
-std::string MenuItem::get_input_with_symbol(bool active_item)
-{
- if(!active_item)
- input_flickering = true;
- else
- {
- if(input_flickering_timer.get_left() < 0)
- {
- if(input_flickering)
- input_flickering = false;
- else
- input_flickering = true;
- input_flickering_timer.start(FLICK_CURSOR_TIME);
- }
- }
-
- char str[1024];
- if(input_flickering)
- sprintf(str,"%s ",input);
- else
- sprintf(str,"%s_",input);
-
- std::string string = str;
-
- return string;
-}
-
-/* Set ControlField for keyboard key */
-void Menu::get_controlfield_key_into_input(MenuItem *item)
-{
- switch(*item->int_p)
- {
- case SDLK_UP:
- item->change_input(_("Up cursor"));
- break;
- case SDLK_DOWN:
- item->change_input(_("Down cursor"));
- break;
- case SDLK_LEFT:
- item->change_input(_("Left cursor"));
- break;
- case SDLK_RIGHT:
- item->change_input(_("Right cursor"));
- break;
- case SDLK_RETURN:
- item->change_input(_("Return"));
- break;
- case SDLK_SPACE:
- item->change_input(_("Space"));
- break;
- case SDLK_RSHIFT:
- item->change_input(_("Right Shift"));
- break;
- case SDLK_LSHIFT:
- item->change_input(_("Left Shift"));
- break;
- case SDLK_RCTRL:
- item->change_input(_("Right Control"));
- break;
- case SDLK_LCTRL:
- item->change_input(_("Left Control"));
- break;
- case SDLK_RALT:
- item->change_input(_("Right Alt"));
- break;
- case SDLK_LALT:
- item->change_input(_("Left Alt"));
- break;
- default:
- {
- char tmp[64];
- snprintf(tmp, 64, "%d", *item->int_p);
- item->change_input(tmp);
- }
- break;
- }
-}
-
-/* Set ControlField for joystick button */
-void Menu::get_controlfield_js_into_input(MenuItem *item)
-{
- std::ostringstream oss;
- oss << "Button " << *item->int_p;
- item->change_input(oss.str().c_str());
-}
-
-/* Free a menu and all its items */
-Menu::~Menu()
-{
- if(item.size() != 0)
- {
- for(unsigned int i = 0; i < item.size(); ++i)
- {
- free(item[i].text);
- free(item[i].input);
- string_list_free(item[i].list);
- }
- }
-}
-
-
-Menu::Menu()
-{
- hit_item = -1;
- menuaction = MENU_ACTION_NONE;
- delete_character = 0;
- mn_input_char = '\0';
-
- pos_x = screen->w/2;
- pos_y = screen->h/2;
- arrange_left = 0;
- active_item = 0;
- effect.init(false);
-
- joystick_timer.init(true);
-}
-
-void Menu::set_pos(int x, int y, float rw, float rh)
-{
- pos_x = x + (int)((float)get_width() * rw);
- pos_y = y + (int)((float)get_height() * rh);
-}
-
-void
-Menu::additem(MenuItemKind kind_, const std::string& text_, int toggle_, Menu* menu_, int id, int* int_p)
-{
- additem(MenuItem::create(kind_, text_.c_str(), toggle_, menu_, id, int_p));
-}
-
-/* Add an item to a menu */
-void
-Menu::additem(MenuItem* pmenu_item)
-{
- item.push_back(*pmenu_item);
- delete pmenu_item;
-}
-
-void
-Menu::clear()
-{
- item.clear();
-}
-
-/* Process actions done on the menu */
-void
-Menu::action()
-{
- hit_item = -1;
- if(item.size() != 0)
- {
- switch(menuaction)
- {
- case MENU_ACTION_UP:
- if (active_item > 0)
- --active_item;
- else
- active_item = int(item.size())-1;
- break;
-
- case MENU_ACTION_DOWN:
- if(active_item < int(item.size())-1)
- ++active_item;
- else
- active_item = 0;
- break;
-
- case MENU_ACTION_LEFT:
- if(item[active_item].kind == MN_STRINGSELECT
- && item[active_item].list->num_items != 0)
- {
- if(item[active_item].list->active_item > 0)
- --item[active_item].list->active_item;
- else
- item[active_item].list->active_item = item[active_item].list->num_items-1;
- }
- break;
-
- case MENU_ACTION_RIGHT:
- if(item[active_item].kind == MN_STRINGSELECT
- && item[active_item].list->num_items != 0)
- {
- if(item[active_item].list->active_item < item[active_item].list->num_items-1)
- ++item[active_item].list->active_item;
- else
- item[active_item].list->active_item = 0;
- }
- break;
-
- case MENU_ACTION_HIT:
- {
- hit_item = active_item;
- switch (item[active_item].kind)
- {
- case MN_GOTO:
- if (item[active_item].target_menu != NULL)
- Menu::push_current(item[active_item].target_menu);
- else
- puts("NULLL");
- break;
-
- case MN_TOGGLE:
- item[active_item].toggled = !item[active_item].toggled;
- break;
-
- case MN_ACTION:
- Menu::set_current(0);
- item[active_item].toggled = true;
- break;
- case MN_TEXTFIELD:
- case MN_NUMFIELD:
- menuaction = MENU_ACTION_DOWN;
- action();
- break;
-
- case MN_BACK:
- Menu::pop_current();
- break;
- default:
- break;
- }
- }
- break;
-
- case MENU_ACTION_REMOVE:
- if(item[active_item].kind == MN_TEXTFIELD
- || item[active_item].kind == MN_NUMFIELD)
- {
- if(item[active_item].input != NULL)
- {
- int i = strlen(item[active_item].input);
-
- while(delete_character > 0) /* remove charactes */
- {
- item[active_item].input[i-1] = '\0';
- delete_character--;
- }
- }
- }
- break;
-
- case MENU_ACTION_INPUT:
- if(item[active_item].kind == MN_TEXTFIELD
- || (item[active_item].kind == MN_NUMFIELD && mn_input_char >= '0' && mn_input_char <= '9'))
- {
- if(item[active_item].input != NULL)
- {
- int i = strlen(item[active_item].input);
- item[active_item].input = (char*) realloc(item[active_item].input,sizeof(char)*(i + 2));
- item[active_item].input[i] = mn_input_char;
- item[active_item].input[i+1] = '\0';
- }
- else
- {
- item[active_item].input = (char*) malloc(2*sizeof(char));
- item[active_item].input[0] = mn_input_char;
- item[active_item].input[1] = '\0';
- }
- }
-
- case MENU_ACTION_NONE:
- break;
- }
- }
-
- MenuItem& new_item = item[active_item];
- if(new_item.kind == MN_DEACTIVE
- || new_item.kind == MN_LABEL
- || new_item.kind == MN_HL)
- {
- // Skip the horzontal line item
- if (menuaction != MENU_ACTION_UP && menuaction != MENU_ACTION_DOWN)
- menuaction = MENU_ACTION_DOWN;
-
- if (item.size() > 1)
- action();
- }
-
- menuaction = MENU_ACTION_NONE;
-
- if (active_item >= int(item.size()))
- active_item = int(item.size()) - 1;
-}
-
-int
-Menu::check()
-{
- if (hit_item != -1)
- return item[hit_item].id;
- else
- return -1;
-}
-
-void
-Menu::draw_item(DrawingContext& context,
- int index, // Position of the current item in the menu
- int menu_width, int menu_height)
-{
- MenuItem& pitem = item[index];
-
- int effect_offset = 0;
- {
- int effect_time = 0;
-
- if(effect.check())
- effect_time = effect.get_left() / 4;
-
- effect_offset = (index % 2) ? effect_time : -effect_time;
- }
-
- Font* text_font = white_text;
- int x_pos = pos_x;
- int y_pos = pos_y + 24*index - menu_height/2 + 12 + effect_offset;
- int shadow_size = 2;
- int text_width = int(text_font->get_text_width(pitem.text));
- int input_width = int(text_font->get_text_width(pitem.input) + 10);
- int list_width =
- int(text_font->get_text_width(string_list_active(pitem.list)));
-
- if (arrange_left)
- x_pos += 24 - menu_width/2 + (text_width + input_width + list_width)/2;
-
- if(index == active_item)
- {
- shadow_size = 3;
- text_font = blue_text;
- }
-
- switch (pitem.kind)
- {
- case MN_DEACTIVE:
- {
- context.draw_text_center(gray_text, pitem.text,
- Vector(0, y_pos - int(blue_text->get_height()/2)),
- LAYER_GUI);
- break;
- }
-
- case MN_HL:
- {
- // TODO
- int x = pos_x - menu_width/2;
- int y = y_pos - 12 - effect_offset;
- /* Draw a horizontal line with a little 3d effect */
- context.draw_filled_rect(Vector(x, y + 6),
- Vector(menu_width, 4), Color(150,200,255,225), LAYER_GUI);
- context.draw_filled_rect(Vector(x, y + 6),
- Vector(menu_width, 2), Color(255,255,255,255), LAYER_GUI);
- break;
- }
- case MN_LABEL:
- {
- context.draw_text_center(white_big_text,
- pitem.text, Vector(0, y_pos - int(white_big_text->get_height()/2)),
- LAYER_GUI);
- break;
- }
- case MN_TEXTFIELD:
- case MN_NUMFIELD:
- case MN_CONTROLFIELD_KB:
- case MN_CONTROLFIELD_JS:
- {
- int width = text_width + input_width + 5;
- int text_pos = screen->w/2 - width/2;
- int input_pos = text_pos + text_width + 10;
-
- context.draw_filled_rect(
- Vector(input_pos - 5, y_pos - 10),
- Vector(input_width + 10, 20),
- Color(255,255,255,255), LAYER_GUI-5);
- context.draw_filled_rect(
- Vector(input_pos - 4, y_pos - 9),
- Vector(input_width + 8, 18),
- Color(0,0,0,128), LAYER_GUI-4);
-
- if(pitem.kind == MN_CONTROLFIELD_KB)
- get_controlfield_key_into_input(&pitem);
- else if (pitem.kind == MN_CONTROLFIELD_JS)
- get_controlfield_js_into_input(&pitem);
-
- if(pitem.kind == MN_TEXTFIELD || pitem.kind == MN_NUMFIELD)
- {
- if(active_item == index)
- context.draw_text(gold_text,
- pitem.get_input_with_symbol(true),
- Vector(input_pos, y_pos - int(gold_text->get_height()/2)),
- LAYER_GUI);
- else
- context.draw_text(gold_text,
- pitem.get_input_with_symbol(false),
- Vector(input_pos, y_pos - int(gold_text->get_height()/2)),
- LAYER_GUI);
- }
- else
- context.draw_text(gold_text, pitem.input,
- Vector(input_pos, y_pos - int(gold_text->get_height()/2)),
- LAYER_GUI);
-
- context.draw_text(text_font, pitem.text,
- Vector(text_pos, y_pos - int(text_font->get_height()/2)),
- LAYER_GUI);
- break;
- }
- case MN_STRINGSELECT:
- {
- int list_pos_2 = list_width + 16;
- int list_pos = list_width/2;
- int text_pos = (text_width + 16)/2;
-
- /* Draw arrows */
- context.draw_surface(arrow_left,
- Vector(x_pos - list_pos + text_pos - 17, y_pos - 8),
- LAYER_GUI);
- context.draw_surface(arrow_right,
- Vector(x_pos - list_pos + text_pos - 1 + list_pos_2, y_pos - 8),
- LAYER_GUI);
-
- /* Draw input background */
- context.draw_filled_rect(
- Vector(x_pos - list_pos + text_pos - 1, y_pos - 10),
- Vector(list_pos_2 + 2, 20),
- Color(255,255,255,255), LAYER_GUI - 4);
- context.draw_filled_rect(
- Vector(x_pos - list_pos + text_pos, y_pos - 9),
- Vector(list_pos_2, 18),
- Color(0,0,0,128), LAYER_GUI - 5);
-
- context.draw_text_center(text_font, string_list_active(pitem.list),
- Vector(text_pos, y_pos - int(text_font->get_height()/2)),
- LAYER_GUI);
- context.draw_text_center(text_font, pitem.text,
- Vector(list_pos_2/2, y_pos - int(text_font->get_height()/2)),
- LAYER_GUI);
- break;
- }
- case MN_BACK:
- {
- context.draw_text_center(text_font, pitem.text,
- Vector(0, y_pos - int(text_font->get_height()/2)),
- LAYER_GUI);
- context.draw_surface(back,
- Vector(x_pos + text_width/2 + 16, y_pos - 8),
- LAYER_GUI);
- break;
- }
-
- case MN_TOGGLE:
- {
- context.draw_text_center(text_font, pitem.text,
- Vector(0, y_pos - (text_font->get_height()/2)),
- LAYER_GUI);
-
- if(pitem.toggled)
- context.draw_surface(checkbox_checked,
- Vector(x_pos + (text_width+16)/2, y_pos - 8),
- LAYER_GUI + 1);
- else
- context.draw_surface(checkbox,
- Vector(x_pos + (text_width+16)/2, y_pos - 8),
- LAYER_GUI + 1);
- break;
- }
- case MN_ACTION:
- context.draw_text_center(text_font, pitem.text,
- Vector(0, y_pos - int(text_font->get_height()/2)),
- LAYER_GUI);
- break;
-
- case MN_GOTO:
- context.draw_text_center(text_font, pitem.text,
- Vector(0, y_pos - int(text_font->get_height()/2)),
- LAYER_GUI);
- break;
- }
-}
-
-int Menu::get_width() const
-{
- /* The width of the menu has to be more than the width of the text
- with the most characters */
- int menu_width = 0;
- for(unsigned int i = 0; i < item.size(); ++i)
- {
- int w = strlen(item[i].text) + (item[i].input ? strlen(item[i].input) + 1 : 0) + strlen(string_list_active(item[i].list));
- if( w > menu_width )
- {
- menu_width = w;
- if( item[i].kind == MN_TOGGLE)
- menu_width += 2;
- }
- }
-
- return (menu_width * 16 + 24);
-}
-
-int Menu::get_height() const
-{
- return item.size() * 24;
-}
-
-/* Draw the current menu. */
-void
-Menu::draw(DrawingContext& context)
-{
- int menu_height = get_height();
- int menu_width = get_width();
-
- /* Draw a transparent background */
- context.draw_filled_rect(
- Vector(pos_x - menu_width/2, pos_y - 24*item.size()/2 - 10),
- Vector(menu_width,menu_height + 20),
- Color(150,180,200,125), LAYER_GUI-10);
-
- for(unsigned int i = 0; i < item.size(); ++i)
- {
- draw_item(context, i, menu_width, menu_height);
- }
-}
-
-MenuItem&
-Menu::get_item_by_id(int id)
-{
- for(std::vector<MenuItem>::iterator i = item.begin(); i != item.end(); ++i)
- {
- if(i->id == id)
- return *i;
- }
-
- assert(false);
- static MenuItem dummyitem;
- return dummyitem;
-}
-
-int Menu::get_active_item_id()
-{
- return item[active_item].id;
-}
-
-bool
-Menu::isToggled(int id)
-{
- return get_item_by_id(id).toggled;
-}
-
-/* Check for menu event */
-void
-Menu::event(SDL_Event& event)
-{
- switch(event.type)
- {
- case SDL_KEYDOWN:
- {
- SDLKey key = key = event.key.keysym.sym;
- SDLMod keymod;
- char ch[2];
- keymod = SDL_GetModState();
-
- /* If the current unicode character is an ASCII character,
- assign it to ch. */
- if ( (event.key.keysym.unicode & 0xFF80) == 0 )
- {
- ch[0] = event.key.keysym.unicode & 0x7F;
- ch[1] = '\0';
- }
- else
- {
- /* An International Character. */
- }
-
- if(item[active_item].kind == MN_CONTROLFIELD_KB)
- {
- if(key == SDLK_ESCAPE)
- {
- Menu::pop_current();
- return;
- }
- *item[active_item].int_p = key;
- menuaction = MENU_ACTION_DOWN;
- return;
- }
-
-
- switch(key)
- {
- case SDLK_UP: /* Menu Up */
- menuaction = MENU_ACTION_UP;
- break;
- case SDLK_DOWN: /* Menu Down */
- menuaction = MENU_ACTION_DOWN;
- break;
- case SDLK_LEFT: /* Menu Up */
- menuaction = MENU_ACTION_LEFT;
- break;
- case SDLK_RIGHT: /* Menu Down */
- menuaction = MENU_ACTION_RIGHT;
- break;
- case SDLK_SPACE:
- if(item[active_item].kind == MN_TEXTFIELD)
- {
- menuaction = MENU_ACTION_INPUT;
- mn_input_char = ' ';
- break;
- }
- case SDLK_RETURN: /* Menu Hit */
- menuaction = MENU_ACTION_HIT;
- break;
- case SDLK_DELETE:
- case SDLK_BACKSPACE:
- menuaction = MENU_ACTION_REMOVE;
- delete_character++;
- break;
- case SDLK_ESCAPE:
- Menu::pop_current();
- break;
- default:
- if( (key >= SDLK_0 && key <= SDLK_9) || (key >= SDLK_a && key <= SDLK_z) || (key >= SDLK_SPACE && key <= SDLK_SLASH))
- {
- menuaction = MENU_ACTION_INPUT;
- mn_input_char = *ch;
- }
- else
- {
- mn_input_char = '\0';
- }
- break;
- }
- }
- break;
-
- case SDL_JOYAXISMOTION:
- if(event.jaxis.axis == joystick_keymap.y_axis)
- {
- if (event.jaxis.value > joystick_keymap.dead_zone && !joystick_timer.started())
- {
- menuaction = MENU_ACTION_DOWN;
- joystick_timer.start(JOYSTICK_MENU_DELAY);
- }
- else if (event.jaxis.value < -joystick_keymap.dead_zone && !joystick_timer.started())
- {
- menuaction = MENU_ACTION_UP;
- joystick_timer.start(JOYSTICK_MENU_DELAY);
- }
- else
- joystick_timer.stop();
- }
- break;
- case SDL_JOYBUTTONDOWN:
- if (item[active_item].kind == MN_CONTROLFIELD_JS)
- {
- // FIXME: This next line does nothing useable, right?
- // *item[active_item].int_p = key;
- menuaction = MENU_ACTION_DOWN;
- }
- menuaction = MENU_ACTION_HIT;
- break;
-
- case SDL_MOUSEBUTTONDOWN:
- {
- int x = event.motion.x;
- int y = event.motion.y;
-
- if(x > pos_x - get_width()/2 &&
- x < pos_x + get_width()/2 &&
- y > pos_y - get_height()/2 &&
- y < pos_y + get_height()/2)
- {
- menuaction = MENU_ACTION_HIT;
- }
- }
- break;
-
- case SDL_MOUSEMOTION:
- {
- int x = event.motion.x;
- int y = event.motion.y;
-
- if(x > pos_x - get_width()/2 &&
- x < pos_x + get_width()/2 &&
- y > pos_y - get_height()/2 &&
- y < pos_y + get_height()/2)
- {
- active_item = (y - (pos_y - get_height()/2)) / 24;
- mouse_cursor->set_state(MC_LINK);
- }
- else
- {
- mouse_cursor->set_state(MC_NORMAL);
- }
- }
- break;
-
- default:
- break;
- }
-}
-
-
-// EOF //
+++ /dev/null
-// $Id$
-//
-// SuperTux
-// Copyright (C) 2004 Tobias Glaesser <tobi.web@gmx.de>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#ifndef SUPERTUX_MENU_H
-#define SUPERTUX_MENU_H
-
-#include <vector>
-
-#include "SDL.h"
-
-#include "screen/surface.h"
-#include "timer.h"
-#include "type.h"
-#include "mousecursor.h"
-
-/* IDs for menus */
-
-enum MainMenuIDs {
- MNID_STARTGAME,
- MNID_LEVELS_CONTRIB,
- MNID_OPTIONMENU,
- MNID_LEVELEDITOR,
- MNID_CREDITS,
- MNID_QUITMAINMENU
- };
-
-enum OptionsMenuIDs {
- MNID_OPENGL,
- MNID_FULLSCREEN,
- MNID_SOUND,
- MNID_MUSIC,
- MNID_SHOWFPS
- };
-
-enum GameMenuIDs {
- MNID_CONTINUE,
- MNID_ABORTLEVEL
- };
-
-enum WorldMapMenuIDs {
- MNID_RETURNWORLDMAP,
- MNID_QUITWORLDMAP
- };
-
-enum LevelEditorMainMenuIDs {
- MNID_RETURNLEVELEDITOR,
- MNID_SUBSETSETTINGS,
- MNID_QUITLEVELEDITOR
- };
-
-enum LevelEditorSubsetSettingsIDs {
- MNID_SUBSETTITLE,
- MNID_SUBSETDESCRIPTION,
- MNID_SUBSETSAVECHANGES
- };
-
-enum LevelEditorSubsetNewIDs {
- MNID_SUBSETNAME,
- MNID_CREATESUBSET
-};
-
-enum LevelEditorSettingsMenuIDs {
- MNID_NAME,
- MNID_AUTHOR,
- MNID_SONG,
- MNID_BGIMG,
- MNID_PARTICLE,
- MNID_LENGTH,
- MNID_HEIGHT,
- MNID_TIME,
- MNID_GRAVITY,
- MNID_BGSPEED,
- MNID_TopRed,
- MNID_TopGreen,
- MNID_TopBlue,
- MNID_BottomRed,
- MNID_BottomGreen,
- MNID_BottomBlue,
- MNID_APPLY
- };
-
-bool confirm_dialog(Surface* background, std::string text);
-
-/* Kinds of menu items */
-enum MenuItemKind {
- MN_ACTION,
- MN_GOTO,
- MN_TOGGLE,
- MN_BACK,
- MN_DEACTIVE,
- MN_TEXTFIELD,
- MN_NUMFIELD,
- MN_CONTROLFIELD_KB,
- MN_CONTROLFIELD_JS,
- MN_STRINGSELECT,
- MN_LABEL,
- MN_HL, /* horizontal line */
-};
-
-class Menu;
-
-class MenuItem
-{
-public:
- MenuItemKind kind;
- int toggled;
- char *text;
- char *input;
- int *int_p; // used for setting keys (can be used for more stuff...)
- int id; // item id
- string_list_type* list;
- Menu* target_menu;
-
- void change_text (const char *text);
- void change_input(const char *text);
-
- static MenuItem* create(MenuItemKind kind, const char *text, int init_toggle, Menu* target_menu, int id, int* int_p);
-
- std::string get_input_with_symbol(bool active_item); // returns the text with an input symbol
-private:
- bool input_flickering;
- Timer input_flickering_timer;
-};
-
-class Menu
-{
-private:
- static std::vector<Menu*> last_menus;
- static Menu* current_;
-
- static void push_current(Menu* pmenu);
- static void pop_current();
-
-public:
- /** Set the current menu, if pmenu is NULL, hide the current menu */
- static void set_current(Menu* pmenu);
-
- /** Return the current active menu or NULL if none is active */
- static Menu* current() { return current_; }
-
-private:
- /* Action done on the menu */
- enum MenuAction {
- MENU_ACTION_NONE = -1,
- MENU_ACTION_UP,
- MENU_ACTION_DOWN,
- MENU_ACTION_LEFT,
- MENU_ACTION_RIGHT,
- MENU_ACTION_HIT,
- MENU_ACTION_INPUT,
- MENU_ACTION_REMOVE
- };
-
- /** Number of the item that got 'hit' (ie. pressed) in the last
- event()/action() call, -1 if none */
- int hit_item;
-
- // position of the menu (ie. center of the menu, not top/left)
- int pos_x;
- int pos_y;
-
- /** input event for the menu (up, down, left, right, etc.) */
- MenuAction menuaction;
-
- /* input implementation variables */
- int delete_character;
- char mn_input_char;
- Timer joystick_timer;
-
-public:
- Timer effect;
- int arrange_left;
- int active_item;
-
- std::vector<MenuItem> item;
-
- Menu();
- ~Menu();
-
- void additem(MenuItem* pmenu_item);
- void additem(MenuItemKind kind, const std::string& text, int init_toggle, Menu* target_menu, int id = -1, int *int_p = NULL);
-
- void action ();
-
- /** Remove all entries from the menu */
- void clear();
-
- /** Return the index of the menu item that was 'hit' (ie. the user
- clicked on it) in the last event() call */
- int check ();
-
- MenuItem& get_item(int index) { return item[index]; }
- MenuItem& get_item_by_id(int id);
-
- int get_active_item_id();
-
- bool isToggled(int id);
-
- void Menu::get_controlfield_key_into_input(MenuItem *item);
- void Menu::get_controlfield_js_into_input(MenuItem *item);
-
- void draw(DrawingContext& context);
- void draw_item(DrawingContext& context,
- int index, int menu_width, int menu_height);
- void set_pos(int x, int y, float rw = 0, float rh = 0);
-
- /** translate a SDL_Event into a menu_action */
- void event(SDL_Event& event);
-
- int get_width() const;
- int get_height() const;
-
- bool is_toggled(int id) const;
-};
-
-extern Surface* checkbox;
-extern Surface* checkbox_checked;
-extern Surface* back;
-extern Surface* arrow_left;
-extern Surface* arrow_right;
-
-extern Menu* contrib_menu;
-extern Menu* contrib_subset_menu;
-extern Menu* main_menu;
-extern Menu* game_menu;
-extern Menu* worldmap_menu;
-extern Menu* options_menu;
-extern Menu* options_keys_menu;
-extern Menu* options_joystick_menu;
-extern Menu* highscore_menu;
-extern Menu* load_game_menu;
-extern Menu* save_game_menu;
-
-#endif /*SUPERTUX_MENU_H*/
-
-/* Local Variables: */
-/* mode: c++ */
-/* End: */
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2004 Ricardo Cruz <rick2@aeiou.pt>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#include "screen/drawing_context.h"
-#include "mousecursor.h"
-
-MouseCursor* MouseCursor::current_ = 0;
-
-MouseCursor::MouseCursor(std::string cursor_file, int frames) : mid_x(0), mid_y(0)
-{
- cursor = new Surface(cursor_file, true);
-
- cur_state = MC_NORMAL;
- cur_frame = 0;
- tot_frames = frames;
-
- timer.init(false);
- timer.start(MC_FRAME_PERIOD);
-
- SDL_ShowCursor(SDL_DISABLE);
-}
-
-MouseCursor::~MouseCursor()
-{
- delete cursor;
-
- SDL_ShowCursor(SDL_ENABLE);
-}
-
-int MouseCursor::state()
-{
- return cur_state;
-}
-
-void MouseCursor::set_state(int nstate)
-{
- cur_state = nstate;
-}
-
-void MouseCursor::set_mid(int x, int y)
-{
- mid_x = x;
- mid_y = y;
-}
-
-void MouseCursor::draw(DrawingContext& context)
-{
- if(cur_state == MC_HIDE)
- return;
-
- int x,y,w,h;
- Uint8 ispressed = SDL_GetMouseState(&x,&y);
- w = cursor->w / tot_frames;
- h = cursor->h / MC_STATES_NB;
- if(ispressed &SDL_BUTTON(1) || ispressed &SDL_BUTTON(2))
- {
- if(cur_state != MC_CLICK)
- {
- state_before_click = cur_state;
- cur_state = MC_CLICK;
- }
- }
- else
- {
- if(cur_state == MC_CLICK)
- cur_state = state_before_click;
- }
-
- if(timer.get_left() < 0 && tot_frames > 1)
- {
- cur_frame++;
- if(cur_frame++ >= tot_frames)
- cur_frame = 0;
-
- timer.start(MC_FRAME_PERIOD);
- }
-
- context.draw_surface_part(cursor, Vector(w*cur_frame, h*cur_state), Vector(w,
- h), Vector(x-mid_x, y-mid_y), LAYER_GUI+100);
-}
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2004 Ricardo Cruz <rick2@aeiou.pt>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#ifndef SUPERTUX_MOUSECURSOR_H
-#define SUPERTUX_MOUSECURSOR_H
-
-#include <string>
-
-#include "timer.h"
-#include "screen/surface.h"
-
-#define MC_FRAME_PERIOD 800 // in ms
-
-#define MC_STATES_NB 3
-enum {
- MC_NORMAL,
- MC_CLICK,
- MC_LINK,
- MC_HIDE
-};
-
-class MouseCursor
-{
-public:
- MouseCursor(std::string cursor_file, int frames);
- ~MouseCursor();
- int state();
- void set_state(int nstate);
- void set_mid(int x, int y);
- void draw(DrawingContext& context);
-
- static MouseCursor* current() { return current_; };
- static void set_current(MouseCursor* pcursor) { current_ = pcursor; };
-
-private:
- int mid_x, mid_y;
- static MouseCursor* current_;
- int state_before_click;
- int cur_state;
- int cur_frame, tot_frames;
- Surface* cursor;
- Timer timer;
-};
-
-#endif /*SUPERTUX_MOUSECURSOR_H*/
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2004 Matthias Braun <matze@braunis.de
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#include "moving_object.h"
-
-MovingObject::MovingObject()
-{
- base.x = base.y = base.width = base.height = 0;
- old_base = base;
-}
-
-MovingObject::~MovingObject()
-{
-}
-
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2004 Matthias Braun <matze@braunis.de
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#ifndef SUPERTUX_MOVING_OBJECT_H
-#define SUPERTUX_MOVING_OBJECT_H
-
-#include "type.h"
-#include "game_object.h"
-#include "vector.h"
-//#include "rectangle.h"
-
-/**
- * Base class for all dynamic/moving game objects. This class contains things
- * for handling the bounding boxes and collision feedback.
- */
-class MovingObject : public GameObject
-{
-public:
- MovingObject();
- virtual ~MovingObject();
-
- /** this function is called when the object collided with any other object
- */
- virtual void collision(const MovingObject& other_object,
- int collision_type) = 0;
-
- Vector get_pos() const
- { return Vector(base.x, base.y); }
-
- base_type base;
- base_type old_base;
-
-protected:
-#if 0 // this will be used in my collision detection rewrite later
- /// the current position of the object
- Vector pos;
- /// the position we want to move until next frame
- Vector new_pos;
- /// the bounding box relative to the current position
- Rectangle bounding_box;
-#endif
-};
-
-#endif /*SUPERTUX_MOVING_OBJECT_H*/
-
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2000 Bill Kendrick <bill@newbreedsoftware.com>
-// Copyright (C) 2004 Matthias Braun <matze@braunis.de>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#include "musicref.h"
-
-MusicRef::MusicRef()
- : music(0)
-{
-}
-
-MusicRef::MusicRef(SoundManager::MusicResource* newmusic)
- : music(newmusic)
-{
- if(music)
- music->refcount++;
-}
-
-MusicRef::~MusicRef()
-{
- if(music) {
- music->refcount--;
- if(music->refcount == 0)
- music->manager->free_music(music);
- }
-}
-
-MusicRef::MusicRef(const MusicRef& other)
- : music(other.music)
-{
- if(music)
- music->refcount++;
-}
-
-MusicRef&
-MusicRef::operator =(const MusicRef& other)
-{
- SoundManager::MusicResource* oldres = music;
- music = other.music;
- if(music)
- music->refcount++;
- if(oldres) {
- oldres->refcount--;
- if(oldres->refcount == 0)
- music->manager->free_music(music);
- }
-
- return *this;
-}
-
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2004 Matthias Braun <matze@braunis.de>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#ifndef SUPERTUX_MUSICREF_H
-#define SUPERTUX_MUSICREF_H
-
-#include "sound_manager.h"
-
-/** This class holds a reference to a music file and maintains a correct
- * refcount for that file.
- */
-class MusicRef
-{
-public:
- MusicRef();
- MusicRef(const MusicRef& other);
- ~MusicRef();
-
- MusicRef& operator= (const MusicRef& other);
-
-private:
- friend class SoundManager;
- MusicRef(SoundManager::MusicResource* music);
-
- SoundManager::MusicResource* music;
-};
-
-#endif /*SUPERTUX_MUSICREF_H*/
-
+++ /dev/null
-// $Id$
-//
-// SuperTux
-// Copyright (C) 2004 Tobias Glaesser <tobi.web@gmx.de>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-// 02111-1307, USA.
-
-#include <cstdio>
-
-#include "scene.h"
-#include "defines.h"
-#include "physic.h"
-#include "timer.h"
-#include "sector.h"
-#include "level.h"
-
-Physic::Physic()
- : ax(0), ay(0), vx(0), vy(0), gravity_enabled(true)
-{
-}
-
-Physic::~Physic()
-{
-}
-
-void
-Physic::reset()
-{
- ax = ay = vx = vy = 0;
- gravity_enabled = true;
-}
-
-void
-Physic::set_velocity_x(float nvx)
-{
- vx = nvx;
-}
-
-void
-Physic::set_velocity_y(float nvy)
-{
- vy = -nvy;
-}
-
-void
-Physic::set_velocity(float nvx, float nvy)
-{
- vx = nvx;
- vy = -nvy;
-}
-
-void Physic::inverse_velocity_x()
-{
-vx = -vx;
-}
-
-void Physic::inverse_velocity_y()
-{
-vy = -vy;
-}
-
-float
-Physic::get_velocity_x()
-{
- return vx;
-}
-
-float
-Physic::get_velocity_y()
-{
- return -vy;
-}
-
-void
-Physic::set_acceleration_x(float nax)
-{
- ax = nax;
-}
-
-void
-Physic::set_acceleration_y(float nay)
-{
- ay = -nay;
-}
-
-void
-Physic::set_acceleration(float nax, float nay)
-{
- ax = nax;
- ay = -nay;
-}
-
-float
-Physic::get_acceleration_x()
-{
- return ax;
-}
-
-float
-Physic::get_acceleration_y()
-{
- return -ay;
-}
-
-void
-Physic::enable_gravity(bool enable_gravity)
-{
- gravity_enabled = enable_gravity;
-}
-
-void
-Physic::apply(float elapsed_time, float &x, float &y)
-{
- float gravity = Sector::current()->gravity;
- float grav;
- if(gravity_enabled)
- grav = gravity / 100.0;
- else
- grav = 0;
-
- x += vx * elapsed_time + ax * elapsed_time * elapsed_time;
- y += vy * elapsed_time + (ay + grav) * elapsed_time * elapsed_time;
- vx += ax * elapsed_time;
- vy += (ay + grav) * elapsed_time;
-}
-
-void
-Physic::apply(Vector& vector, float elapsed_time)
-{
- apply(elapsed_time, vector.x, vector.y);
-}
-
+++ /dev/null
-// $Id$
-//
-// SuperTux
-// Copyright (C) 2004 Tobias Glaesser <tobi.web@gmx.de>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-// 02111-1307, USA.
-
-#ifndef SUPERTUX_PHYSIC_H
-#define SUPERTUX_PHYSIC_H
-
-/** This is a very simplistic physics engine handling accelerated and constant
- * movement along with gravity.
- */
-class Physic
-{
-public:
- Physic();
- ~Physic();
-
- /** resets all velocities and accelerations to 0 */
- void reset();
-
- /** sets velocity to a fixed value */
- void set_velocity(float vx, float vy);
-
- void set_velocity_x(float vx);
- void set_velocity_y(float vy);
-
- /** velocities invertion */
- void inverse_velocity_x();
- void inverse_velocity_y();
-
- float get_velocity_x();
- float get_velocity_y();
-
- /** sets acceleration applied to the object. (Note that gravity is
- * eventually added to the vertical acceleration)
- */
- void set_acceleration(float ax, float ay);
-
- void set_acceleration_x(float ax);
- void set_acceleration_y(float ay);
-
- float get_acceleration_x();
- float get_acceleration_y();
-
- /** enables or disables handling of gravity */
- void enable_gravity(bool gravity_enabled);
-
- /** applies the physical simulation to given x and y coordinates */
- void apply(float frame_ratio, float &x, float &y);
-
- /** applies the physical simulation to given x and y coordinates */
- void apply(Vector& vector, float frame_ratio);
-
-private:
- /// horizontal and vertical acceleration
- float ax, ay;
- /// horizontal and vertical velocity
- float vx, vy;
- /// should we respect gravity in out calculations?
- bool gravity_enabled;
-};
-
-#endif /*SUPERTUX_PHYSIC_H*/
+++ /dev/null
-all:
- cd .. && $(MAKE)
-
-# EOF #
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2004 Matthias Braun <matze@braunis.de
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-#include <algorithm>
-#include <cassert>
-#include <iostream>
-
-#include "drawing_context.h"
-#include "surface.h"
-#include "globals.h"
-#include "font.h"
-
-DrawingContext::DrawingContext()
-{
-transform.draw_effect = NONE_EFFECT;
-}
-
-DrawingContext::~DrawingContext()
-{
-}
-
-void
-DrawingContext::draw_surface(const Surface* surface, const Vector& position,
- int layer, Uint32 drawing_effect)
-{
- assert(surface != 0);
-
- DrawingRequest request;
-
- request.type = SURFACE;
- request.layer = layer;
- request.request_data = const_cast<Surface*> (surface);
- request.pos = transform.apply(position);
- request.drawing_effect = drawing_effect;
- request.drawing_effect = transform.draw_effect | drawing_effect;
-
- drawingrequests.push_back(request);
-}
-
-void
-DrawingContext::draw_surface_part(const Surface* surface, const Vector& source,
- const Vector& size, const Vector& dest, int layer, Uint32 drawing_effect)
-{
- assert(surface != 0);
-
- DrawingRequest request;
-
- request.type = SURFACE_PART;
- request.layer = layer;
- request.pos = transform.apply(dest);
- request.drawing_effect = drawing_effect;
-
- SurfacePartRequest* surfacepartrequest = new SurfacePartRequest();
- surfacepartrequest->size = size;
- surfacepartrequest->source = source;
- surfacepartrequest->surface = surface;
- request.request_data = surfacepartrequest;
-
- drawingrequests.push_back(request);
-}
-
-void
-DrawingContext::draw_text(Font* font, const std::string& text,
- const Vector& position, int layer, Uint32 drawing_effect)
-{
- DrawingRequest request;
-
- request.type = TEXT;
- request.layer = layer;
- request.pos = transform.apply(position);
- request.drawing_effect = drawing_effect;
-
- TextRequest* textrequest = new TextRequest;
- textrequest->font = font;
- textrequest->text = text;
- request.request_data = textrequest;
-
- drawingrequests.push_back(request);
-}
-
-void
-DrawingContext::draw_text_center(Font* font, const std::string& text,
- const Vector& position, int layer, Uint32 drawing_effect)
-{
- DrawingRequest request;
-
- request.type = TEXT;
- request.layer = layer;
- request.pos = transform.apply(position) + Vector(screen->w/2 -
- font->get_text_width(text)/2, 0);
- request.drawing_effect = drawing_effect;
-
- TextRequest* textrequest = new TextRequest;
- textrequest->font = font;
- textrequest->text = text;
- request.request_data = textrequest;
-
- drawingrequests.push_back(request);
-}
-
-void
-DrawingContext::draw_gradient(Color top, Color bottom, int layer)
-{
- DrawingRequest request;
-
- request.type = GRADIENT;
- request.layer = layer;
- request.pos = Vector(0,0);
-
- GradientRequest* gradientrequest = new GradientRequest;
- gradientrequest->top = top;
- gradientrequest->bottom = bottom;
- request.request_data = gradientrequest;
-
- drawingrequests.push_back(request);
-}
-
-void
-DrawingContext::draw_filled_rect(const Vector& topleft, const Vector& size,
- Color color, int layer)
-{
- DrawingRequest request;
-
- request.type = FILLRECT;
- request.layer = layer;
- request.pos = transform.apply(topleft);
-
- FillRectRequest* fillrectrequest = new FillRectRequest;
- fillrectrequest->size = size;
- fillrectrequest->color = color;
- request.request_data = fillrectrequest;
-
- drawingrequests.push_back(request);
-}
-
-void
-DrawingContext::draw_surface_part(DrawingRequest& request)
-{
- SurfacePartRequest* surfacepartrequest
- = (SurfacePartRequest*) request.request_data;
-
- surfacepartrequest->surface->impl->draw_part(
- surfacepartrequest->source.x, surfacepartrequest->source.y,
- request.pos.x, request.pos.y,
- surfacepartrequest->size.x, surfacepartrequest->size.y, 255,
- request.drawing_effect);
-
- delete surfacepartrequest;
-}
-
-void
-DrawingContext::draw_gradient(DrawingRequest& request)
-{
- GradientRequest* gradientrequest = (GradientRequest*) request.request_data;
- const Color& top = gradientrequest->top;
- const Color& bottom = gradientrequest->bottom;
-
-#ifndef NOOPENGL
- if(use_gl)
- {
- glBegin(GL_QUADS);
- glColor3ub(top.red, top.green, top.blue);
- glVertex2f(0, 0);
- glVertex2f(screen->w, 0);
- glColor3ub(bottom.red, bottom.green, bottom.blue);
- glVertex2f(screen->w, screen->h);
- glVertex2f(0, screen->h);
- glEnd();
- }
- else
- {
-#endif
- if(&top == &bottom)
- {
- fillrect(0, 0, screen->w, screen->h, top.red, top.green, top.blue);
- }
- else
- {
- float redstep = (float(bottom.red)-float(top.red)) / float(screen->h);
- float greenstep = (float(bottom.green)-float(top.green)) / float(screen->h);
- float bluestep = (float(bottom.blue) - float(top.blue)) / float(screen->h);
-
- for(float y = 0; y < screen->h; y += 2)
- fillrect(0, (int)y, screen->w, 2,
- int(float(top.red) + redstep * y),
- int(float(top.green) + greenstep * y),
- int(float(top.blue) + bluestep * y), 255);
- }
-#ifndef NOOPENGL
-
- }
-#endif
-
- delete gradientrequest;
-}
-
-void
-DrawingContext::draw_text(DrawingRequest& request)
-{
- TextRequest* textrequest = (TextRequest*) request.request_data;
-
- textrequest->font->draw(textrequest->text, request.pos, request.drawing_effect);
-
- delete textrequest;
-}
-
-void
-DrawingContext::draw_filled_rect(DrawingRequest& request)
-{
- FillRectRequest* fillrectrequest = (FillRectRequest*) request.request_data;
-
- float x = request.pos.x;
- float y = request.pos.y;
- float w = fillrectrequest->size.x;
- float h = fillrectrequest->size.y;
-
-#ifndef NOOPENGL
- if(use_gl)
- {
- glEnable(GL_BLEND);
- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- glColor4ub(fillrectrequest->color.red, fillrectrequest->color.green,
- fillrectrequest->color.blue, fillrectrequest->color.alpha);
-
- glBegin(GL_POLYGON);
- glVertex2f(x, y);
- glVertex2f(x+w, y);
- glVertex2f(x+w, y+h);
- glVertex2f(x, y+h);
- glEnd();
- glDisable(GL_BLEND);
- }
- else
- {
-#endif
- SDL_Rect src, rect;
- SDL_Surface *temp = NULL;
-
- rect.x = (int)x;
- rect.y = (int)y;
- rect.w = (int)w;
- rect.h = (int)h;
-
- if(fillrectrequest->color.alpha != 255)
- {
- temp = SDL_CreateRGBSurface(screen->flags, rect.w, rect.h, screen->format->BitsPerPixel,
- screen->format->Rmask,
- screen->format->Gmask,
- screen->format->Bmask,
- screen->format->Amask);
-
-
- src.x = 0;
- src.y = 0;
- src.w = rect.w;
- src.h = rect.h;
-
- SDL_FillRect(temp, &src, SDL_MapRGB(screen->format,
- fillrectrequest->color.red, fillrectrequest->color.green,
- fillrectrequest->color.blue));
-
- SDL_SetAlpha(temp, SDL_SRCALPHA, fillrectrequest->color.alpha);
-
- SDL_BlitSurface(temp,0,screen,&rect);
-
- SDL_FreeSurface(temp);
- }
- else
- SDL_FillRect(screen, &rect, SDL_MapRGB(screen->format,
- fillrectrequest->color.red, fillrectrequest->color.green,
- fillrectrequest->color.blue));
-
-#ifndef NOOPENGL
-
- }
-#endif
-
- delete fillrectrequest;
-}
-
-void
-DrawingContext::do_drawing()
-{
- std::stable_sort(drawingrequests.begin(), drawingrequests.end());
-
- for(DrawingRequests::iterator i = drawingrequests.begin();
- i != drawingrequests.end(); ++i) {
- switch(i->type) {
- case SURFACE:
- {
- const Surface* surface = (const Surface*) i->request_data;
- surface->impl->draw(i->pos.x, i->pos.y, 255, i->drawing_effect);
- break;
- }
- case SURFACE_PART:
- draw_surface_part(*i);
- break;
- case GRADIENT:
- draw_gradient(*i);
- break;
- case TEXT:
- draw_text(*i);
- break;
- case FILLRECT:
- draw_filled_rect(*i);
- break;
- }
- }
-
- // update screen
- if(use_gl)
- SDL_GL_SwapBuffers();
- else
- SDL_Flip(screen);
-
- drawingrequests.clear();
-}
-
-void
-DrawingContext::push_transform()
-{
- transformstack.push_back(transform);
-}
-
-void
-DrawingContext::pop_transform()
-{
- assert(!transformstack.empty());
-
- transform = transformstack.back();
- transformstack.pop_back();
-}
-
-void
-DrawingContext::set_drawing_effect(int effect)
-{
- transform.draw_effect = effect;
-}
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2004 Matthias Braun <matze@braunis.de
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-#ifndef SUPERTUX_DRAWINGCONTEXT_H
-#define SUPERTUX_DRAWINGCONTEXT_H
-
-#include <vector>
-#include <string>
-
-#include "SDL.h"
-
-#include "vector.h"
-#include "screen.h"
-
-class Surface;
-class Font;
-
-// some constants for predefined layer values
-enum {
- LAYER_BACKGROUND0 = -300,
- LAYER_BACKGROUND1 = -200,
- LAYER_BACKGROUNDTILES = -100,
- LAYER_TILES = 0,
- LAYER_OBJECTS = 100,
- LAYER_FOREGROUNDTILES = 200,
- LAYER_FOREGROUND0 = 300,
- LAYER_FOREGROUND1 = 400,
- LAYER_GUI = 500
-};
-
-/**
- * This class provides functions for drawing things on screen. It also
- * maintains a stack of transforms that are applied to graphics.
- */
-class DrawingContext
-{
-public:
- DrawingContext();
- ~DrawingContext();
-
- /** Adds a drawing request for a surface into the request list */
- void draw_surface(const Surface* surface, const Vector& position, int layer,
- Uint32 drawing_effect = NONE_EFFECT);
- /** Adds a drawing request for part of a surface */
- void draw_surface_part(const Surface* surface, const Vector& source,
- const Vector& size, const Vector& dest, int layer,
- Uint32 drawing_effect = NONE_EFFECT);
- /** draws a text */
- void draw_text(Font* font, const std::string& text, const Vector& position,
- int layer, Uint32 drawing_effect = NONE_EFFECT);
- /** draws aligned text */
- void draw_text_center(Font* font, const std::string& text,
- const Vector& position, int layer, Uint32 drawing_effect = NONE_EFFECT);
- /** draws a color gradient onto the whole screen */
- void draw_gradient(Color from, Color to, int layer);
- /** fills a rectangle */
- void draw_filled_rect(const Vector& topleft, const Vector& size,
- Color color, int layer);
-
- /** Processes all pending drawing requests and flushes the list */
- void do_drawing();
-
- const Vector& get_translation() const
- { return transform.translation; }
- void set_translation(const Vector& newtranslation)
- { transform.translation = newtranslation; }
-
- void push_transform();
- void pop_transform();
-
- /** apply that effect in the next draws (effects are listed on surface.h) */
- void set_drawing_effect(int effect);
-
-private:
- class Transform
- {
- public:
- Vector translation; // only translation for now...
-
- Vector apply(const Vector& v) const
- {
- return v - translation;
- }
-
- int draw_effect;
- };
-
- /// the transform stack
- std::vector<Transform> transformstack;
- /// the currently active transform
- Transform transform;
-
- enum RequestType
- {
- SURFACE, SURFACE_PART, TEXT, GRADIENT, FILLRECT
- };
-
- struct SurfacePartRequest
- {
- const Surface* surface;
- Vector source, size;
- };
-
- struct TextRequest
- {
- Font* font;
- std::string text;
- };
-
- struct GradientRequest
- {
- Color top, bottom;
- Vector size;
- };
-
- struct FillRectRequest
- {
- Color color;
- Vector size;
- };
-
- struct DrawingRequest
- {
- int layer;
- Uint32 drawing_effect;
-
- RequestType type;
- Vector pos;
-
- void* request_data;
-
- bool operator<(const DrawingRequest& other) const
- {
- return layer < other.layer;
- }
- };
-
- void draw_surface_part(DrawingRequest& request);
- void draw_text(DrawingRequest& request);
- void draw_gradient(DrawingRequest& request);
- void draw_filled_rect(DrawingRequest& request);
-
- typedef std::vector<DrawingRequest> DrawingRequests;
- DrawingRequests drawingrequests;
-};
-
-#endif /*SUPERTUX_DRAWINGCONTEXT_H*/
-
+++ /dev/null
-// $Id$
-//
-// SuperTux
-// Copyright (C) 2004 Tobias Glaesser <tobi.web@gmx.de>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-// 02111-1307, USA.
-
-#include <cstdlib>
-#include <cstring>
-
-#include "globals.h"
-#include "defines.h"
-#include "screen.h"
-#include "font.h"
-#include "drawing_context.h"
-#include "../lispreader.h"
-#include "../musicref.h"
-#include "../resources.h"
-
-Font::Font(const std::string& file, FontType ntype, int nw, int nh,
- int nshadowsize)
- : chars(0), shadow_chars(0), type(ntype), w(nw), h(nh),
- shadowsize(nshadowsize)
-{
- chars = new Surface(file, true);
-
- switch(type) {
- case TEXT:
- first_char = 32;
- break;
- case NUM:
- first_char = 48;
- break;
- }
- last_char = first_char + (chars->h / h) * 16;
- if(last_char > 127) // we have left out some control chars at 128-159
- last_char += 32;
-
- // Load shadow font.
- if(shadowsize > 0) {
- SDL_Surface* conv = SDL_DisplayFormatAlpha(chars->impl->get_sdl_surface());
- int pixels = conv->w * conv->h;
- SDL_LockSurface(conv);
- for(int i = 0; i < pixels; ++i) {
- Uint32 *p = (Uint32 *)conv->pixels + i;
- *p = *p & conv->format->Amask;
- }
- SDL_UnlockSurface(conv);
- SDL_SetAlpha(conv, SDL_SRCALPHA, 128);
- shadow_chars = new Surface(conv, true);
- SDL_FreeSurface(conv);
- }
-}
-
-Font::~Font()
-{
- delete chars;
- delete shadow_chars;
-}
-
-float
-Font::get_height() const
-{
- return h;
-}
-
-float
-Font::get_text_width(const std::string& text) const
-{
- return text.size() * w;
-}
-
-void
-Font::draw(const std::string& text, const Vector& pos, Uint32 drawing_effect)
-{
- if(shadowsize > 0)
- draw_chars(shadow_chars, text, pos + Vector(shadowsize, shadowsize),
- drawing_effect);
-
- draw_chars(chars, text, pos, drawing_effect);
-}
-
-void
-Font::draw_chars(Surface* pchars, const std::string& text, const Vector& pos,
- Uint32 drawing_effect)
-{
- SurfaceImpl* impl = pchars->impl;
-
- Vector p = pos;
- for(size_t i = 0; i < text.size(); ++i)
- {
- int c = (unsigned char) text[i];
- if(c > 127) // correct for the 32 controlchars at 128-159
- c -= 32;
- // a non-printable character?
- if(c == '\n') {
- p.x = pos.x;
- p.y += h + 2;
- continue;
- }
- if(c == ' ' || c < first_char || c > last_char) {
- p.x += w;
- continue;
- }
-
- int index = c - first_char;
- int source_x = (index % 16) * w;
- int source_y = (index / 16) * h;
-
- impl->draw_part(source_x, source_y, p.x, p.y, w, h, 255, drawing_effect);
- p.x += w;
- }
-}
-
-/* --- SCROLL TEXT FUNCTION --- */
-
-#define MAX_VEL 10
-#define SPEED_INC 0.01
-#define SCROLL 60
-#define ITEMS_SPACE 4
-
-void display_text_file(const std::string& file, float scroll_speed)
-{
- std::string text;
- std::vector<std::string> names;
-
- LispReader* reader = LispReader::load(datadir + "/" + file, "supertux-text");
-
- if(!reader)
- {
- std::cerr << "Error: Could not open text. Ignoring...\n";
- return;
- }
-
- reader->read_string("text", text, true);
- std::string background_file;
- reader->read_string("background", background_file, true);
- std::string music_file;
- reader->read_string("music", music_file, true);
- std::string show_after_text;
- reader->read_string("show-after", show_after_text, true);
- delete reader;
-
- if(!music_file.empty())
- {
- MusicRef theme = sound_manager->load_music(datadir + "/music/" + music_file);
- sound_manager->play_music(theme);
- }
-
- // Split text string lines into a vector
- names.clear();
- unsigned int i, l;
- i = 0;
- while(true)
- {
- l = text.find("\n", i);
-
- if(l == std::string::npos)
- {
- char temp[1024];
- temp[text.copy(temp, text.size() - i, i)] = '\0';
- names.push_back(temp);
- break;
- }
-
- char temp[1024];
- temp[text.copy(temp, l-i, i)] = '\0';
- names.push_back(temp);
-
- i = l+1;
- }
-
- // load background image
- Surface* background = new Surface(datadir + "/images/background/" + background_file, false);
-
- int done = 0;
- float scroll = 0;
- float speed = scroll_speed / 50;
-
- DrawingContext context;
- SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
-
- Uint32 lastticks = SDL_GetTicks();
- while(!done)
- {
- /* in case of input, exit */
- SDL_Event event;
- while(SDL_PollEvent(&event))
- switch(event.type)
- {
- case SDL_KEYDOWN:
- switch(event.key.keysym.sym)
- {
- case SDLK_UP:
- speed -= SPEED_INC;
- break;
- case SDLK_DOWN:
- speed += SPEED_INC;
- break;
- case SDLK_SPACE:
- case SDLK_RETURN:
- if(speed >= 0)
- scroll += SCROLL;
- break;
- case SDLK_ESCAPE:
- done = 1;
- break;
- default:
- break;
- }
- break;
- case SDL_QUIT:
- done = 1;
- break;
- default:
- break;
- }
-
- if(speed > MAX_VEL)
- speed = MAX_VEL;
- else if(speed < -MAX_VEL)
- speed = -MAX_VEL;
-
- /* draw the credits */
- context.draw_surface(background, Vector(0,0), 0);
-
- float y = 0;
- for(size_t i = 0; i < names.size(); i++) {
- if(names[i].size() == 0) {
- y += white_text->get_height() + ITEMS_SPACE;
- continue;
- }
-
- Font* font = 0;
- switch(names[i][0])
- {
- case ' ': font = white_small_text; break;
- case '\t': font = white_text; break;
- case '-': font = white_big_text; break;
- case '*': font = blue_text; break;
- default: font = blue_text; break;
- }
-
- context.draw_text_center(font,
- names[i].substr(1, names[i].size()-1),
- Vector(0, screen->h + y - scroll), LAYER_FOREGROUND1);
- y += font->get_height() + ITEMS_SPACE;
- }
-
- context.do_drawing();
-
- if(screen->h+y-scroll < 0 && 20+screen->h+y-scroll < 0)
- done = 1;
-
- Uint32 ticks = SDL_GetTicks();
- scroll += speed * (ticks - lastticks);
- lastticks = ticks;
- if(scroll < 0)
- scroll = 0;
-
- SDL_Delay(10);
- }
-
- SDL_EnableKeyRepeat(0, 0); // disables key repeating
- delete background;
-
- if(!show_after_text.empty())
- {
- display_text_file(show_after_text, scroll_speed);
- }
-}
-
+++ /dev/null
-// $Id$
-//
-// SuperTux
-// Copyright (C) 2004 Tobias Glaesser <tobi.web@gmx.de>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-// 02111-1307, USA.
-
-#ifndef SUPERTUX_FONT_H
-#define SUPERTUX_FONT_H
-
-#include <string>
-
-#include "surface.h"
-#include "vector.h"
-
-/** Reads a text file (using LispReader, so it as to be in its formatting)
- and displays it in a StarTrek fashion */
-void display_text_file(const std::string& file, float scroll_speed);
-
-/* Text type */
-class Font
-{
-public:
- /* Kinds of texts. */
- enum FontType {
- TEXT, // images for all characters
- NUM // only images for numbers
- };
-
- Font(const std::string& file, FontType type, int w, int h, int shadowsize=2);
- ~Font();
-
- /** returns the height of the font */
- float get_height() const;
- /** returns the width of a given text. (Note that I won't add a normal
- * get_width function here, as we might switch to variable width fonts in the
- * future.
- */
- float get_text_width(const std::string& text) const;
-
-private:
- friend class DrawingContext;
-
- void draw(const std::string& text, const Vector& pos,
- Uint32 drawing_effect = NONE_EFFECT);
- void draw_chars(Surface* pchars, const std::string& text,
- const Vector& position, Uint32 drawing_effect);
-
- Surface* chars;
- Surface* shadow_chars;
- FontType type;
- int w;
- int h;
- int shadowsize;
-
- /// the number of the first character that is represented in the font
- int first_char;
- /// the number of the last character that is represented in the font
- int last_char;
-};
-
-#endif /*SUPERTUX_FONT_H*/
-
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2000 Bill Kendrick <bill@newbreedsoftware.com>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#include <iostream>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <cerrno>
-
-#include <unistd.h>
-
-#include "SDL.h"
-#include "SDL_image.h"
-
-#ifndef WIN32
-#include <sys/types.h>
-#include <ctype.h>
-#endif
-
-#include "defines.h"
-#include "globals.h"
-#include "screen.h"
-#include "setup.h"
-#include "drawing_context.h"
-#include "type.h"
-
-/* 'Stolen' from the SDL documentation.
- * Set the pixel at (x, y) to the given value
- * NOTE: The surface must be locked before calling this!
- */
-void putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
-{
- int bpp = surface->format->BytesPerPixel;
- /* Here p is the address to the pixel we want to set */
- Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
-
- switch(bpp)
- {
- case 1:
- *p = pixel;
- break;
-
- case 2:
- *(Uint16 *)p = pixel;
- break;
-
- case 3:
- if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
- {
- p[0] = (pixel >> 16) & 0xff;
- p[1] = (pixel >> 8) & 0xff;
- p[2] = pixel & 0xff;
- }
- else
- {
- p[0] = pixel & 0xff;
- p[1] = (pixel >> 8) & 0xff;
- p[2] = (pixel >> 16) & 0xff;
- }
- break;
-
- case 4:
- *(Uint32 *)p = pixel;
- break;
- }
-}
-
-/* Draw a single pixel on the screen. */
-void drawpixel(int x, int y, Uint32 pixel)
-{
- /* Lock the screen for direct access to the pixels */
- if ( SDL_MUSTLOCK(screen) )
- {
- if ( SDL_LockSurface(screen) < 0 )
- {
- fprintf(stderr, "Can't lock screen: %s\n", SDL_GetError());
- return;
- }
- }
-
- if(!(x < 0 || y < 0 || x > screen->w || y > screen->h))
- putpixel(screen, x, y, pixel);
-
- if ( SDL_MUSTLOCK(screen) )
- {
- SDL_UnlockSurface(screen);
- }
- /* Update just the part of the display that we've changed */
- SDL_UpdateRect(screen, x, y, 1, 1);
-}
-
-/* --- FILL A RECT --- */
-
-void fillrect(float x, float y, float w, float h, int r, int g, int b, int a)
-{
-if(w < 0)
- {
- x += w;
- w = -w;
- }
-if(h < 0)
- {
- y += h;
- h = -h;
- }
-
-#ifndef NOOPENGL
- if(use_gl)
- {
- glEnable(GL_BLEND);
- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- glColor4ub(r, g, b,a);
-
- glBegin(GL_POLYGON);
- glVertex2f(x, y);
- glVertex2f(x+w, y);
- glVertex2f(x+w, y+h);
- glVertex2f(x, y+h);
- glEnd();
- glDisable(GL_BLEND);
- }
- else
- {
-#endif
- SDL_Rect src, rect;
- SDL_Surface *temp = NULL;
-
- rect.x = (int)x;
- rect.y = (int)y;
- rect.w = (int)w;
- rect.h = (int)h;
-
- if(a != 255)
- {
- temp = SDL_CreateRGBSurface(screen->flags, rect.w, rect.h, screen->format->BitsPerPixel,
- screen->format->Rmask,
- screen->format->Gmask,
- screen->format->Bmask,
- screen->format->Amask);
-
-
- src.x = 0;
- src.y = 0;
- src.w = rect.w;
- src.h = rect.h;
-
- SDL_FillRect(temp, &src, SDL_MapRGB(screen->format, r, g, b));
-
- SDL_SetAlpha(temp, SDL_SRCALPHA, a);
-
- SDL_BlitSurface(temp,0,screen,&rect);
-
- SDL_FreeSurface(temp);
- }
- else
- SDL_FillRect(screen, &rect, SDL_MapRGB(screen->format, r, g, b));
-
-#ifndef NOOPENGL
-
- }
-#endif
-}
-
-/* Needed for line calculations */
-#define SGN(x) ((x)>0 ? 1 : ((x)==0 ? 0:(-1)))
-#define ABS(x) ((x)>0 ? (x) : (-x))
-
-void
-draw_line(float x1, float y1, float x2, float y2, int r, int g, int b, int a)
-{
-#ifndef NOOPENGL
- if(use_gl)
- {
- glEnable(GL_BLEND);
- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- glColor4ub(r, g, b,a);
-
- glBegin(GL_LINES);
- glVertex2f(x1, y1);
- glVertex2f(x2, y2);
- glEnd();
- glDisable(GL_BLEND);
- }
- else
- {
-#endif
- /* Basic unantialiased Bresenham line algorithm */
- int lg_delta, sh_delta, cycle, lg_step, sh_step;
- Uint32 color = SDL_MapRGBA(screen->format, r, g, b, a);
-
- lg_delta = (int)(x2 - x1);
- sh_delta = (int)(y2 - y1);
- lg_step = SGN(lg_delta);
- lg_delta = ABS(lg_delta);
- sh_step = SGN(sh_delta);
- sh_delta = ABS(sh_delta);
- if (sh_delta < lg_delta)
- {
- cycle = lg_delta >> 1;
- while (x1 != x2)
- {
- drawpixel((int)x1, (int)y1, color);
- cycle += sh_delta;
- if (cycle > lg_delta)
- {
- cycle -= lg_delta;
- y1 += sh_step;
- }
- x1 += lg_step;
- }
- drawpixel((int)x1, (int)y1, color);
- }
- cycle = sh_delta >> 1;
- while (y1 != y2)
- {
- drawpixel((int)x1, (int)y1, color);
- cycle += lg_delta;
- if (cycle > sh_delta)
- {
- cycle -= sh_delta;
- x1 += lg_step;
- }
- y1 += sh_step;
- }
- drawpixel((int)x1, (int)y1, color);
-#ifndef NOOPENGL
-
- }
-#endif
-}
-
-#define LOOP_DELAY 20.0
-
-void fadeout(int fade_time)
-{
- float alpha_inc = 256 / (fade_time / LOOP_DELAY);
- float alpha = 256;
-
- while(alpha > 0)
- {
- alpha -= alpha_inc;
- fillrect(0, 0, screen->w, screen->h, 0,0,0, (int)alpha_inc); // left side
-
- DrawingContext context; // ugly...
- context.do_drawing();
-
- SDL_Delay(int(LOOP_DELAY));
- }
-
- fillrect(0, 0, screen->w, screen->h, 0, 0, 0, 255);
-
- DrawingContext context;
- context.draw_text_center(white_text, "Loading...",
- Vector(0, screen->h/2), LAYER_FOREGROUND1);
- context.do_drawing();
-}
-
-void shrink_fade(const Vector& point, int fade_time)
-{
- float left_inc = point.x / ((float)fade_time / LOOP_DELAY);
- float right_inc = (screen->w - point.x) / ((float)fade_time / LOOP_DELAY);
- float up_inc = point.y / ((float)fade_time / LOOP_DELAY);
- float down_inc = (screen->h - point.y) / ((float)fade_time / LOOP_DELAY);
-
- float left_cor = 0, right_cor = 0, up_cor = 0, down_cor = 0;
-
- while(left_cor < point.x && right_cor < screen->w - point.x &&
- up_cor < point.y && down_cor < screen->h - point.y)
- {
- left_cor += left_inc;
- right_cor += right_inc;
- up_cor += up_inc;
- down_cor += down_inc;
-
- fillrect(0, 0, left_cor, screen->h, 0,0,0); // left side
- fillrect(screen->w - right_cor, 0, right_cor, screen->h, 0,0,0); // right side
- fillrect(0, 0, screen->w, up_cor, 0,0,0); // up side
- fillrect(0, screen->h - down_cor, screen->w, down_cor+1, 0,0,0); // down side
- DrawingContext context; // ugly...
- context.do_drawing();
-
- SDL_Delay(int(LOOP_DELAY));
- }
-}
-
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2000 Bill Kendrick <bill@newbreedsoftware.com>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#ifndef SUPERTUX_SCREEN_H
-#define SUPERTUX_SCREEN_H
-
-#include <SDL.h>
-#ifndef NOOPENGL
-#include <SDL_opengl.h>
-#endif
-#include <iostream>
-class Color
-{
-public:
- Color()
- : red(0), green(0), blue(0), alpha(255)
- {}
-
- Color(Uint8 red_, Uint8 green_, Uint8 blue_, Uint8 alpha_ = 255)
- : red(red_), green(green_), blue(blue_), alpha(alpha_)
- {}
-
- Color(const Color& o)
- : red(o.red), green(o.green), blue(o.blue), alpha(o.alpha)
- { }
-
- bool operator==(const Color& o)
- { if(red == o.red && green == o.green &&
- blue == o.blue && alpha == o.alpha)
- return true;
- return false; }
-
- Uint8 red, green, blue, alpha;
-};
-
-#include "surface.h"
-
-class Vector;
-
-void putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel);
-void drawpixel(int x, int y, Uint32 pixel);
-void fillrect(float x, float y, float w, float h, int r, int g, int b, int a = 255);
-void draw_line(float x1, float y1, float x2, int r, int g, int b, int a = 255);
-
-void fadeout(int fade_time);
-void shrink_fade(const Vector& point, int fade_time);
-
-#endif /*SUPERTUX_SCREEN_H*/
+++ /dev/null
-// $Id$
-//
-// SuperTux
-// Copyright (C) 2004 Tobias Glaesser <tobi.web@gmx.de>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-// 02111-1307, USA.
-
-#include <cassert>
-#include <iostream>
-#include <algorithm>
-
-#include "SDL.h"
-#include "SDL_image.h"
-
-#include "surface.h"
-#include "globals.h"
-#include "setup.h"
-
-Surface::Surfaces Surface::surfaces;
-
-SurfaceData::SurfaceData(SDL_Surface* temp, bool use_alpha_)
- : type(SURFACE), surface(0), use_alpha(use_alpha_)
-{
- // Copy the given surface and make sure that it is not stored in
- // video memory
- surface = SDL_CreateRGBSurface(temp->flags & (~SDL_HWSURFACE),
- temp->w, temp->h,
- temp->format->BitsPerPixel,
- temp->format->Rmask,
- temp->format->Gmask,
- temp->format->Bmask,
- temp->format->Amask);
- if(!surface)
- st_abort("No memory left.", "");
- SDL_SetAlpha(temp,0,0);
- SDL_BlitSurface(temp, NULL, surface, NULL);
-}
-
-SurfaceData::SurfaceData(const std::string& file_, bool use_alpha_)
- : type(LOAD), surface(0), file(file_), use_alpha(use_alpha_)
-{}
-
-SurfaceData::SurfaceData(const std::string& file_, int x_, int y_, int w_, int h_, bool use_alpha_)
- : type(LOAD_PART), surface(0), file(file_), use_alpha(use_alpha_),
- x(x_), y(y_), w(w_), h(h_)
-{}
-
-SurfaceData::SurfaceData(Color top_gradient_, Color bottom_gradient_, int w_, int h_)
- : type(GRADIENT), surface(0), use_alpha(false), w(w_), h(h_)
-{
-top_gradient = top_gradient_;
-bottom_gradient = bottom_gradient_;
-}
-
-
-SurfaceData::~SurfaceData()
-{
- SDL_FreeSurface(surface);
-}
-
-SurfaceImpl*
-SurfaceData::create()
-{
-#ifndef NOOPENGL
- if (use_gl)
- return create_SurfaceOpenGL();
- else
- return create_SurfaceSDL();
-#else
- return create_SurfaceSDL();
-#endif
-}
-
-SurfaceSDL*
-SurfaceData::create_SurfaceSDL()
-{
- switch(type)
- {
- case LOAD:
- return new SurfaceSDL(file, use_alpha);
- case LOAD_PART:
- return new SurfaceSDL(file, x, y, w, h, use_alpha);
- case SURFACE:
- return new SurfaceSDL(surface, use_alpha);
- case GRADIENT:
- return new SurfaceSDL(top_gradient, bottom_gradient, w, h);
- }
- assert(0);
-}
-
-SurfaceOpenGL*
-SurfaceData::create_SurfaceOpenGL()
-{
-#ifndef NOOPENGL
- switch(type)
- {
- case LOAD:
- return new SurfaceOpenGL(file, use_alpha);
- case LOAD_PART:
- return new SurfaceOpenGL(file, x, y, w, h, use_alpha);
- case SURFACE:
- return new SurfaceOpenGL(surface, use_alpha);
- case GRADIENT:
- return new SurfaceOpenGL(top_gradient, bottom_gradient, w, h);
- }
-#endif
- assert(0);
-}
-
-#ifndef NOOPENGL
-/* Quick utility function for texture creation */
-static int power_of_two(int input)
-{
- int value = 1;
-
- while ( value < input )
- {
- value <<= 1;
- }
- return value;
-}
-#endif
-
-Surface::Surface(SDL_Surface* surf, bool use_alpha)
- : data(surf, use_alpha), w(0), h(0)
-{
- impl = data.create();
- if (impl)
- {
- w = impl->w;
- h = impl->h;
- }
- surfaces.push_back(this);
-}
-
-Surface::Surface(const std::string& file, bool use_alpha)
- : data(file, use_alpha), w(0), h(0)
-{
- impl = data.create();
- if (impl)
- {
- w = impl->w;
- h = impl->h;
- }
- surfaces.push_back(this);
-}
-
-Surface::Surface(const std::string& file, int x, int y, int w, int h, bool use_alpha)
- : data(file, x, y, w, h, use_alpha), w(0), h(0)
-{
- impl = data.create();
- if (impl)
- {
- w = impl->w;
- h = impl->h;
- }
- surfaces.push_back(this);
-}
-
-Surface::Surface(Color top_background, Color bottom_background, int w_, int h_)
- : data(top_background, bottom_background, 0, 0), w(0), h(0)
-{
- // FIXME: Gradient surfaces currently don't accept width/height
- // If nonzero values are passed to data.create(), supertux
- // crashes.
- impl = data.create();
- if (impl)
- {
- w = impl->w;
- h = impl->h;
- }
- surfaces.push_back(this);
-}
-
-void
-Surface::reload()
-{
- delete impl;
- impl = data.create();
- if (impl)
- {
- w = impl->w;
- h = impl->h;
- }
-}
-
-Surface::~Surface()
-{
-#ifdef DEBUG
- bool found = false;
- for(std::list<Surface*>::iterator i = surfaces.begin(); i != surfaces.end();
- ++i)
- {
- if(*i == this)
- {
- found = true; break;
- }
- }
- if(!found)
- printf("Error: Surface freed twice!!!\n");
-#endif
- surfaces.remove(this);
- delete impl;
-}
-
-void
-Surface::reload_all()
-{
- for(Surfaces::iterator i = surfaces.begin(); i != surfaces.end(); ++i)
- {
- (*i)->reload();
- }
-}
-
-void
-Surface::debug_check()
-{
- for(Surfaces::iterator i = surfaces.begin(); i != surfaces.end(); ++i)
- {
- printf("Surface not freed: T:%d F:%s.\n", (*i)->data.type,
- (*i)->data.file.c_str());
- }
-}
-
-void
-Surface::resize(int w_, int h_)
-{
- if (impl)
- {
- w = w_;
- h = h_;
- if (impl->resize(w_,h_) == -2)
- reload();
- }
-}
-
-SDL_Surface*
-sdl_surface_part_from_file(const std::string& file, int x, int y, int w, int h, bool use_alpha)
-{
- SDL_Rect src;
- SDL_Surface * sdl_surface;
- SDL_Surface * temp;
- SDL_Surface * conv;
-
- temp = IMG_Load(file.c_str());
-
- if (temp == NULL)
- st_abort("Can't load", file);
-
- /* Set source rectangle for conv: */
-
- src.x = x;
- src.y = y;
- src.w = w;
- src.h = h;
-
- conv = SDL_CreateRGBSurface(temp->flags, w, h, temp->format->BitsPerPixel,
- temp->format->Rmask,
- temp->format->Gmask,
- temp->format->Bmask,
- temp->format->Amask);
-
- /* #if SDL_BYTEORDER == SDL_BIG_ENDIAN
- 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff);
- #else
-
- 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000);
- #endif*/
-
- SDL_SetAlpha(temp,0,0);
-
- SDL_BlitSurface(temp, &src, conv, NULL);
- if(use_alpha == false && !use_gl)
- sdl_surface = SDL_DisplayFormat(conv);
- else
- sdl_surface = SDL_DisplayFormatAlpha(conv);
-
- if (sdl_surface == NULL)
- st_abort("Can't covert to display format", file);
-
- if (use_alpha == false && !use_gl)
- SDL_SetAlpha(sdl_surface, 0, 0);
-
- SDL_FreeSurface(temp);
- SDL_FreeSurface(conv);
-
- return sdl_surface;
-}
-
-SDL_Surface*
-sdl_surface_from_file(const std::string& file, bool use_alpha)
-{
- SDL_Surface* sdl_surface;
- SDL_Surface* temp;
-
- temp = IMG_Load(file.c_str());
-
- if (temp == NULL)
- st_abort("Can't load", file);
-
- if(use_alpha == false && !use_gl)
- sdl_surface = SDL_DisplayFormat(temp);
- else
- sdl_surface = SDL_DisplayFormatAlpha(temp);
-
- if (sdl_surface == NULL)
- st_abort("Can't covert to display format", file);
-
- if (use_alpha == false && !use_gl)
- SDL_SetAlpha(sdl_surface, 0, 0);
-
- SDL_FreeSurface(temp);
-
- return sdl_surface;
-}
-
-SDL_Surface*
-sdl_surface_from_sdl_surface(SDL_Surface* sdl_surf, bool use_alpha)
-{
- SDL_Surface* sdl_surface;
- Uint32 saved_flags;
- Uint8 saved_alpha;
-
- /* Save the alpha blending attributes */
- saved_flags = sdl_surf->flags&(SDL_SRCALPHA|SDL_RLEACCELOK);
- saved_alpha = sdl_surf->format->alpha;
- if ( (saved_flags & SDL_SRCALPHA)
- == SDL_SRCALPHA )
- {
- SDL_SetAlpha(sdl_surf, 0, 0);
- }
-
- if(use_alpha == false && !use_gl)
- sdl_surface = SDL_DisplayFormat(sdl_surf);
- else
- sdl_surface = SDL_DisplayFormatAlpha(sdl_surf);
-
- /* Restore the alpha blending attributes */
- if ( (saved_flags & SDL_SRCALPHA)
- == SDL_SRCALPHA )
- {
- SDL_SetAlpha(sdl_surface, saved_flags, saved_alpha);
- }
-
- if (sdl_surface == NULL)
- st_abort("Can't covert to display format", "SURFACE");
-
- if (use_alpha == false && !use_gl)
- SDL_SetAlpha(sdl_surface, 0, 0);
-
- return sdl_surface;
-}
-
-SDL_Surface*
-sdl_surface_from_gradient(Color top, Color bottom, int w, int h)
-{
- SDL_Surface* sdl_surface;
-
- sdl_surface = SDL_CreateRGBSurface(screen->flags, w, h,
- screen->format->BitsPerPixel, screen->format->Rmask,
- screen->format->Gmask, screen->format->Bmask, screen->format->Amask);
-
- if(sdl_surface == NULL)
- st_abort("Cannot create surface for the gradient", "SURFACE");
-
- if(top == bottom)
- {
- SDL_FillRect(sdl_surface, NULL, SDL_MapRGB(sdl_surface->format,
- top.red, top.green, top.blue));
- }
- else
- {
- float redstep = (float(bottom.red)-float(top.red)) / float(h);
- float greenstep = (float(bottom.green)-float(top.green)) / float(h);
- float bluestep = (float(bottom.blue) - float(top.blue)) / float(h);
-
- SDL_Rect rect;
- rect.x = 0;
- rect.w = w;
- rect.h = 1;
- for(float y = 0; y < h; y++)
- {
- rect.y = (int)y;
- SDL_FillRect(sdl_surface, &rect, SDL_MapRGB(sdl_surface->format,
- int(float(top.red) + redstep * y),
- int(float(top.green) + greenstep * y),
- int(float(top.blue) + bluestep * y)));
- }
- }
-
- return sdl_surface;
-}
-
-//---------------------------------------------------------------------------
-
-SurfaceImpl::SurfaceImpl()
-{}
-
-SurfaceImpl::~SurfaceImpl()
-{
- SDL_FreeSurface(sdl_surface);
-}
-
-SDL_Surface* SurfaceImpl::get_sdl_surface() const
-{
- return sdl_surface;
-}
-
-int SurfaceImpl::resize(int w_, int h_)
-{
- w = w_;
- h = h_;
- SDL_Rect dest;
- dest.x = 0;
- dest.y = 0;
- dest.w = w;
- dest.h = h;
- int ret = SDL_SoftStretch(sdl_surface, NULL,
- sdl_surface, &dest);
- return ret;
-}
-
-#ifndef NOOPENGL
-SurfaceOpenGL::SurfaceOpenGL(SDL_Surface* surf, bool use_alpha)
-{
- sdl_surface = sdl_surface_from_sdl_surface(surf, use_alpha);
- create_gl(sdl_surface,&gl_texture);
-
- w = sdl_surface->w;
- h = sdl_surface->h;
-}
-
-SurfaceOpenGL::SurfaceOpenGL(const std::string& file, bool use_alpha)
-{
- sdl_surface = sdl_surface_from_file(file, use_alpha);
- create_gl(sdl_surface,&gl_texture);
-
- w = sdl_surface->w;
- h = sdl_surface->h;
-}
-
-SurfaceOpenGL::SurfaceOpenGL(const std::string& file_, int x_, int y_, int w_, int h_, bool use_alpha_)
-{
- sdl_surface = sdl_surface_part_from_file(file_,x_,y_,w_,h_,use_alpha_);
-
- create_gl(sdl_surface, &gl_texture);
-
- w = sdl_surface->w;
- h = sdl_surface->h;
-}
-
-SurfaceOpenGL::SurfaceOpenGL(Color top_gradient, Color bottom_gradient, int w, int h)
-{
- sdl_surface = sdl_surface_from_gradient(top_gradient, bottom_gradient, w, h);
- create_gl(sdl_surface, &gl_texture);
-
- w = sdl_surface->w;
- h = sdl_surface->h;
-}
-
-SurfaceOpenGL::~SurfaceOpenGL()
-{
- glDeleteTextures(1, &gl_texture);
-}
-
-void
-SurfaceOpenGL::create_gl(SDL_Surface * surf, GLuint * tex)
-{
- Uint32 saved_flags;
- Uint8 saved_alpha;
- int w, h;
- SDL_Surface *conv;
-
- w = power_of_two(surf->w);
- h = power_of_two(surf->h),
-
-#if SDL_BYTEORDER == SDL_BIG_ENDIAN
- conv = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, surf->format->BitsPerPixel,
- 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff);
-#else
- conv = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, surf->format->BitsPerPixel,
- 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000);
-#endif
-
- /* Save the alpha blending attributes */
- saved_flags = surf->flags&(SDL_SRCALPHA|SDL_RLEACCELOK);
- saved_alpha = surf->format->alpha;
- if ( (saved_flags & SDL_SRCALPHA)
- == SDL_SRCALPHA )
- {
- SDL_SetAlpha(surf, 0, 0);
- }
-
- SDL_BlitSurface(surf, 0, conv, 0);
-
- /* Restore the alpha blending attributes */
- if ( (saved_flags & SDL_SRCALPHA)
- == SDL_SRCALPHA )
- {
- SDL_SetAlpha(surf, saved_flags, saved_alpha);
- }
-
- // We check all the pixels of the surface to figure out which
- // internal format OpenGL should use for storing it, ie. if no alpha
- // is present store in RGB instead of RGBA, this saves a few bytes
- // of memory, but much more importantly it makes the game look
- // *much* better in 16bit color mode
- int internal_format = GL_RGB10_A2;
- bool has_alpha = false;
-
- unsigned char* buf = static_cast<unsigned char*>(conv->pixels);
- for (int y = 0; y < surf->h; ++y)
- for (int x = 0; x < surf->w; ++x)
- {
- if (buf[(conv->pitch*y + x*4) + 3] != 255)
- {
- has_alpha = true;
- break;
- }
- }
-
- if (!has_alpha)
- {
- internal_format = GL_RGB;
- }
-
- glGenTextures(1, &*tex);
- glBindTexture(GL_TEXTURE_2D , *tex);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
- glPixelStorei(GL_UNPACK_ROW_LENGTH, conv->pitch / conv->format->BytesPerPixel);
- glTexImage2D(GL_TEXTURE_2D, 0, internal_format, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, conv->pixels);
- glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
-
- SDL_FreeSurface(conv);
-}
-
-int
-SurfaceOpenGL::draw(float x, float y, Uint8 alpha, Uint32 effect)
-{
- float pw = power_of_two(w);
- float ph = power_of_two(h);
-
- if(effect & SEMI_TRANSPARENT)
- alpha = 128;
-
- glEnable(GL_TEXTURE_2D);
- glEnable(GL_BLEND);
- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
- glColor4ub(alpha, alpha, alpha, alpha);
-
- glBindTexture(GL_TEXTURE_2D, gl_texture);
-
- glBegin(GL_QUADS);
-
- if(effect & VERTICAL_FLIP)
- {
- glTexCoord2f(0, 0);
- glVertex2f(x, (float)h+y);
-
- glTexCoord2f((float)w / pw, 0);
- glVertex2f((float)w+x, (float)h+y);
-
- glTexCoord2f((float)w / pw, (float)h / ph);
- glVertex2f((float)w+x, y);
-
- glTexCoord2f(0, (float)h / ph);
- glVertex2f(x, y);
- }
- else
- {
- glTexCoord2f(0, 0);
- glVertex2f(x, y);
-
- glTexCoord2f((float)w / pw, 0);
- glVertex2f((float)w+x, y);
-
- glTexCoord2f((float)w / pw, (float)h / ph);
- glVertex2f((float)w+x, (float)h+y);
-
- glTexCoord2f(0, (float)h / ph);
- glVertex2f(x, (float)h+y);
- }
- glEnd();
-
- glDisable(GL_TEXTURE_2D);
- glDisable(GL_BLEND);
-
- return 0;
-}
-
-int
-SurfaceOpenGL::draw_part(float sx, float sy, float x, float y, float w, float h, Uint8 alpha, Uint32 effect)
-{
- float pw = power_of_two(int(this->w));
- float ph = power_of_two(int(this->h));
-
- if(effect & SEMI_TRANSPARENT)
- alpha = 128;
-
- glBindTexture(GL_TEXTURE_2D, gl_texture);
-
- glEnable(GL_BLEND);
- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
- glColor4ub(alpha, alpha, alpha, alpha);
-
- glEnable(GL_TEXTURE_2D);
-
-
- glBegin(GL_QUADS);
-
- if(effect & VERTICAL_FLIP)
- {
- glTexCoord2f(sx / pw, sy / ph);
- glVertex2f(x, y);
-
- glTexCoord2f((float)(sx + w) / pw, sy / ph);
- glVertex2f(w+x, y);
-
- glTexCoord2f((sx+w) / pw, (sy+h) / ph);
- glVertex2f(w +x, h+y);
-
- glTexCoord2f(sx / pw, (float)(sy+h) / ph);
- glVertex2f(x, h+y);
- }
- else
- {
- glTexCoord2f(sx / pw, (float)(sy+h) / ph);
- glVertex2f(x, h+y);
-
- glTexCoord2f((sx+w) / pw, (sy+h) / ph);
- glVertex2f(w +x, h+y);
-
- glTexCoord2f((float)(sx + w) / pw, sy / ph);
- glVertex2f(w+x, y);
-
- glTexCoord2f(sx / pw, sy / ph);
- glVertex2f(x, y);
- }
-
- glEnd();
-
- glDisable(GL_TEXTURE_2D);
- glDisable(GL_BLEND);
-
- return 0;
-}
-
-#if 0
-int
-SurfaceOpenGL::draw_stretched(float x, float y, int sw, int sh, Uint8 alpha)
-{
- float pw = power_of_two(int(this->w));
- float ph = power_of_two(int(this->h));
-
- glBindTexture(GL_TEXTURE_2D, gl_texture);
-
- glEnable(GL_BLEND);
- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
- glColor4ub(alpha, alpha, alpha, alpha);
-
- glEnable(GL_TEXTURE_2D);
-
-
- glBegin(GL_QUADS);
- glTexCoord2f(0, 0);
- glVertex2f(x, y);
- glTexCoord2f((float)w / pw, 0);
- glVertex2f(sw+x, y);
- glTexCoord2f((float)w / pw, (float)h / ph); glVertex2f((float)sw+x, (float)sh+y);
- glVertex2f(sw +x, sh+y);
- glTexCoord2f(0, (float)h / ph);
- glVertex2f(x, sh+y);
- glEnd();
-
- glDisable(GL_TEXTURE_2D);
- glDisable(GL_BLEND);
-
- return 0;
-}
-#endif
-
-#endif
-
-SurfaceSDL::SurfaceSDL(SDL_Surface* surf, bool use_alpha)
-{
- sdl_surface = sdl_surface_from_sdl_surface(surf, use_alpha);
- w = sdl_surface->w;
- h = sdl_surface->h;
-}
-
-SurfaceSDL::SurfaceSDL(const std::string& file, bool use_alpha)
-{
- sdl_surface = sdl_surface_from_file(file, use_alpha);
- w = sdl_surface->w;
- h = sdl_surface->h;
-}
-
-SurfaceSDL::SurfaceSDL(const std::string& file, int x, int y, int w, int h, bool use_alpha)
-{
- sdl_surface = sdl_surface_part_from_file(file, x, y, w, h, use_alpha);
- w = sdl_surface->w;
- h = sdl_surface->h;
-}
-
-SurfaceSDL::SurfaceSDL(Color top_gradient, Color bottom_gradient, int w, int h)
-{
- sdl_surface = sdl_surface_from_gradient(top_gradient, bottom_gradient, w, h);
- w = sdl_surface->w;
- h = sdl_surface->h;
-}
-
-int
-SurfaceSDL::draw(float x, float y, Uint8 alpha, Uint32 effect)
-{
- SDL_Rect dest;
-
- dest.x = (int)x;
- dest.y = (int)y;
- dest.w = w;
- dest.h = h;
-
- if(effect & SEMI_TRANSPARENT)
- alpha = 128;
-
- if(effect & VERTICAL_FLIP) // FIXME: feel free to replace this hack
- {
- for(float sy = 0; sy < h; sy++)
- if(draw_part(0, sy, x, y+(h-sy), w, 1, alpha, NONE_EFFECT) == -2)
- return -2;
- return 0;
- }
-
- if(alpha != 255)
- {
- /* Create a Surface, make it using colorkey, blit surface into temp, apply alpha
- to temp sur, blit the temp into the screen */
- /* Note: this has to be done, since SDL doesn't allow to set alpha to surfaces that
- already have an alpha mask yet... */
-
- SDL_Surface* sdl_surface_copy = SDL_CreateRGBSurface (sdl_surface->flags,
- sdl_surface->w, sdl_surface->h, sdl_surface->format->BitsPerPixel,
- sdl_surface->format->Rmask, sdl_surface->format->Gmask,
- sdl_surface->format->Bmask,
- 0);
- int colorkey = SDL_MapRGB(sdl_surface_copy->format, 255, 0, 255);
- SDL_FillRect(sdl_surface_copy, NULL, colorkey);
- SDL_SetColorKey(sdl_surface_copy, SDL_SRCCOLORKEY, colorkey);
-
-
- SDL_BlitSurface(sdl_surface, NULL, sdl_surface_copy, NULL);
- SDL_SetAlpha(sdl_surface_copy ,SDL_SRCALPHA,alpha);
-
- int ret = SDL_BlitSurface(sdl_surface_copy, NULL, screen, &dest);
-
- SDL_FreeSurface (sdl_surface_copy);
- return ret;
- }
-
- int ret = SDL_BlitSurface(sdl_surface, NULL, screen, &dest);
-
- return ret;
-}
-
-int
-SurfaceSDL::draw_part(float sx, float sy, float x, float y, float w, float h, Uint8 alpha, Uint32 effect)
-{
- SDL_Rect src, dest;
-
- src.x = (int)sx;
- src.y = (int)sy;
- src.w = (int)w;
- src.h = (int)h;
-
- dest.x = (int)x;
- dest.y = (int)y;
- dest.w = (int)w;
- dest.h = (int)h;
-
- if(effect & SEMI_TRANSPARENT)
- alpha = 128;
-
- if(effect & VERTICAL_FLIP) // FIXME: feel free to replace this hack
- {
- for(float sy_ = sy; sy_ < h; sy_++)
- if(draw_part(sx, sy_, x, y+(h-sy_), w, 1, alpha, NONE_EFFECT) == -2)
- return -2;
- return 0;
- }
-
- if(alpha != 255)
- {
- /* Create a Surface, make it using colorkey, blit surface into temp, apply alpha
- to temp sur, blit the temp into the screen */
- /* Note: this has to be done, since SDL doesn't allow to set alpha to surfaces that
- already have an alpha mask yet... */
-
- SDL_Surface* sdl_surface_copy = SDL_CreateRGBSurface (sdl_surface->flags,
- sdl_surface->w, sdl_surface->h, sdl_surface->format->BitsPerPixel,
- sdl_surface->format->Rmask, sdl_surface->format->Gmask,
- sdl_surface->format->Bmask,
- 0);
- int colorkey = SDL_MapRGB(sdl_surface_copy->format, 255, 0, 255);
- SDL_FillRect(sdl_surface_copy, NULL, colorkey);
- SDL_SetColorKey(sdl_surface_copy, SDL_SRCCOLORKEY, colorkey);
-
-
- SDL_BlitSurface(sdl_surface, NULL, sdl_surface_copy, NULL);
- SDL_SetAlpha(sdl_surface_copy ,SDL_SRCALPHA,alpha);
-
- int ret = SDL_BlitSurface(sdl_surface_copy, NULL, screen, &dest);
-
- SDL_FreeSurface (sdl_surface_copy);
- return ret;
- }
-
- int ret = SDL_BlitSurface(sdl_surface, &src, screen, &dest);
-
- return ret;
-}
-
-#if 0
-int
-SurfaceSDL::draw_stretched(float x, float y, int sw, int sh, Uint8 alpha, bool update)
-{
- SDL_Rect dest;
-
- dest.x = (int)x;
- dest.y = (int)y;
- dest.w = (int)sw;
- dest.h = (int)sh;
-
- if(alpha != 255)
- SDL_SetAlpha(sdl_surface ,SDL_SRCALPHA,alpha);
-
-
- SDL_Surface* sdl_surface_copy = SDL_CreateRGBSurface (sdl_surface->flags,
- sw, sh, sdl_surface->format->BitsPerPixel,
- sdl_surface->format->Rmask, sdl_surface->format->Gmask,
- sdl_surface->format->Bmask,
- 0);
-
- SDL_BlitSurface(sdl_surface, NULL, sdl_surface_copy, NULL);
- SDL_SoftStretch(sdl_surface_copy, NULL, sdl_surface_copy, &dest);
-
- int ret = SDL_BlitSurface(sdl_surface_copy,NULL,screen,&dest);
- SDL_FreeSurface(sdl_surface_copy);
-
- if (update == UPDATE)
- update_rect(screen, dest.x, dest.y, dest.w, dest.h);
-
- return ret;
-}
-#endif
-
-SurfaceSDL::~SurfaceSDL()
-{}
-
-/* EOF */
+++ /dev/null
-// $Id$
-//
-// SuperTux
-// Copyright (C) 2004 Tobias Glaesser <tobi.web@gmx.de>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-// 02111-1307, USA.
-
-#ifndef SUPERTUX_TEXTURE_H
-#define SUPERTUX_TEXTURE_H
-
-#include <string>
-#include <list>
-
-#ifndef NOOPENGL
-#include "SDL_opengl.h"
-#endif
-
-#include "SDL.h"
-
-#include "screen.h"
-#include "vector.h"
-
-SDL_Surface* sdl_surface_from_sdl_surface(SDL_Surface* sdl_surf, bool use_alpha);
-SDL_Surface* sdl_surface_from_nothing();
-
-class SurfaceImpl;
-class SurfaceSDL;
-class SurfaceOpenGL;
-class DrawingContext;
-
-/// bitset for drawing effects
-enum {
- /** Don't apply anything */
- NONE_EFFECT = 0x0000,
- /** Draw the Surface upside down */
- VERTICAL_FLIP = 0x0001,
- /** Draw the Surface with alpha equal to 128 */
- SEMI_TRANSPARENT = 0x0002
- };
-
-/** This class holds all the data necessary to construct a surface */
-class SurfaceData
-{
-public:
- enum ConstructorType { LOAD, LOAD_PART, SURFACE, GRADIENT };
- ConstructorType type;
- SDL_Surface* surface;
- std::string file;
- bool use_alpha;
- int x;
- int y;
- int w;
- int h;
- Color top_gradient;
- Color bottom_gradient;
-
- SurfaceData(SDL_Surface* surf, bool use_alpha_);
- SurfaceData(const std::string& file_, bool use_alpha_);
- SurfaceData(const std::string& file_, int x_, int y_, int w_, int h_, bool use_alpha_);
- SurfaceData(Color top_gradient_, Color bottom_gradient_, int w_, int h_);
- ~SurfaceData();
-
- SurfaceSDL* create_SurfaceSDL();
- SurfaceOpenGL* create_SurfaceOpenGL();
- SurfaceImpl* create();
-};
-
-/** Container class that holds a surface, necessary so that we can
- switch Surface implementations (OpenGL, SDL) on the fly */
-class Surface
-{
-public:
- SurfaceData data;
- SurfaceImpl* impl;
- int w;
- int h;
-
- typedef std::list<Surface*> Surfaces;
- static Surfaces surfaces;
-public:
- static void reload_all();
- static void debug_check();
-
- Surface(SDL_Surface* surf, bool use_alpha);
- Surface(const std::string& file, bool use_alpha);
- Surface(const std::string& file, int x, int y, int w, int h, bool use_alpha);
- Surface(Color top_gradient, Color bottom_gradient, int w_, int h_);
- ~Surface();
-
- /** Reload the surface, which is necesarry in case of a mode swich */
- void reload();
-
- void resize(int widht, int height);
-};
-
-/** Surface implementation, all implementation have to inherit from
- this class */
-class SurfaceImpl
-{
-protected:
- SDL_Surface* sdl_surface;
-
-public:
- int w;
- int h;
-
-public:
- SurfaceImpl();
- virtual ~SurfaceImpl();
-
- /** Return 0 on success, -2 if surface needs to be reloaded */
- virtual int draw(float x, float y, Uint8 alpha, Uint32 effect = NONE_EFFECT) = 0;
- virtual int draw_part(float sx, float sy, float x, float y, float w, float h, Uint8 alpha, Uint32 effect = NONE_EFFECT) = 0;
-#if 0
- virtual int draw_stretched(float x, float y, int w, int h, Uint8 alpha, bool update) = 0;
-#endif
- int resize(int w_, int h_);
-
- SDL_Surface* get_sdl_surface() const; // @evil@ try to avoid this function
-};
-
-class SurfaceSDL : public SurfaceImpl
-{
-public:
- SurfaceSDL(SDL_Surface* surf, bool use_alpha);
- SurfaceSDL(const std::string& file, bool use_alpha);
- SurfaceSDL(const std::string& file, int x, int y, int w, int h, bool use_alpha);
- SurfaceSDL(Color top_gradient, Color bottom_gradient, int w, int h);
- virtual ~SurfaceSDL();
-
- int draw(float x, float y, Uint8 alpha, Uint32 effect = NONE_EFFECT);
- int draw_part(float sx, float sy, float x, float y, float w, float h, Uint8 alpha, Uint32 effect = NONE_EFFECT);
-#if 0
- int draw_stretched(float x, float y, int w, int h, Uint8 alpha);
-#endif
-};
-
-#ifndef NOOPENGL
-class SurfaceOpenGL : public SurfaceImpl
-{
-public:
- GLuint gl_texture;
-
-public:
- SurfaceOpenGL(SDL_Surface* surf, bool use_alpha);
- SurfaceOpenGL(const std::string& file, bool use_alpha);
- SurfaceOpenGL(const std::string& file, int x, int y, int w, int h, bool use_alpha);
- SurfaceOpenGL(Color top_gradient, Color bottom_gradient, int w, int h);
-
- virtual ~SurfaceOpenGL();
-
- int draw(float x, float y, Uint8 alpha, Uint32 effect = NONE_EFFECT);
- int draw_part(float sx, float sy, float x, float y, float w, float h, Uint8 alpha, Uint32 effect = NONE_EFFECT);
-#if 0
- int draw_stretched(float x, float y, int w, int h, Uint8 alpha);
-#endif
-
-private:
- void create_gl(SDL_Surface * surf, GLuint * tex);
-};
-#endif
-
-#endif /*SUPERTUX_TEXTURE_H*/
-
-/* Local Variables: */
-/* mode: c++ */
-/* End: */
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2000 Bill Kendrick <bill@newbreedsoftware.com>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#include <cassert>
-#include <cstdio>
-#include <iostream>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <cerrno>
-#include <unistd.h>
-
-#include "SDL.h"
-#include "SDL_image.h"
-#ifndef NOOPENGL
-#include "SDL_opengl.h"
-#endif
-
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <dirent.h>
-#ifndef WIN32
-#include <libgen.h>
-#endif
-
-#include <cctype>
-
-#include "defines.h"
-#include "globals.h"
-#include "setup.h"
-#include "screen/screen.h"
-#include "screen/surface.h"
-#include "menu.h"
-#include "gameloop.h"
-#include "configfile.h"
-#include "scene.h"
-#include "worldmap.h"
-#include "resources.h"
-#include "intro.h"
-#include "sound_manager.h"
-#include "gettext.h"
-
-#include "player.h"
-
-#ifdef WIN32
-#define mkdir(dir, mode) mkdir(dir)
-// on win32 we typically don't want LFS paths
-#undef DATA_PREFIX
-#define DATA_PREFIX "./data/"
-#endif
-
-/* Screen proprities: */
-/* Don't use this to test for the actual screen sizes. Use screen->w/h instead! */
-#define SCREEN_W 800
-#define SCREEN_H 600
-
-/* Local function prototypes: */
-
-void seticon(void);
-void usage(char * prog, int ret);
-
-/* Does the given file exist and is it accessible? */
-int faccessible(const char *filename)
-{
- struct stat filestat;
- if (stat(filename, &filestat) == -1)
- {
- return false;
- }
- else
- {
- if(S_ISREG(filestat.st_mode))
- return true;
- else
- return false;
- }
-}
-
-/* Can we write to this location? */
-int fwriteable(const char *filename)
-{
- FILE* fi;
- fi = fopen(filename, "wa");
- if (fi == NULL)
- {
- return false;
- }
- return true;
-}
-
-/* Makes sure a directory is created in either the SuperTux home directory or the SuperTux base directory.*/
-int fcreatedir(const char* relative_dir)
-{
- char path[1024];
- snprintf(path, 1024, "%s/%s/", st_dir, relative_dir);
- if(mkdir(path,0755) != 0)
- {
- snprintf(path, 1024, "%s/%s/", datadir.c_str(), relative_dir);
- if(mkdir(path,0755) != 0)
- {
- return false;
- }
- else
- {
- return true;
- }
- }
- else
- {
- return true;
- }
-}
-
-FILE * opendata(const char * rel_filename, const char * mode)
-{
- char * filename = NULL;
- FILE * fi;
-
- filename = (char *) malloc(sizeof(char) * (strlen(st_dir) +
- strlen(rel_filename) + 1));
-
- strcpy(filename, st_dir);
- /* Open the high score file: */
-
- strcat(filename, rel_filename);
-
- /* Try opening the file: */
- fi = fopen(filename, mode);
-
- if (fi == NULL)
- {
- fprintf(stderr, "Warning: Unable to open the file \"%s\" ", filename);
-
- if (strcmp(mode, "r") == 0)
- fprintf(stderr, "for read!!!\n");
- else if (strcmp(mode, "w") == 0)
- fprintf(stderr, "for write!!!\n");
- }
- free( filename );
-
- return(fi);
-}
-
-/* Get all names of sub-directories in a certain directory. */
-/* Returns the number of sub-directories found. */
-/* Note: The user has to free the allocated space. */
-string_list_type dsubdirs(const char *rel_path,const char* expected_file)
-{
- DIR *dirStructP;
- struct dirent *direntp;
- string_list_type sdirs;
- char filename[1024];
- char path[1024];
-
- string_list_init(&sdirs);
- sprintf(path,"%s/%s",st_dir,rel_path);
- if((dirStructP = opendir(path)) != NULL)
- {
- while((direntp = readdir(dirStructP)) != NULL)
- {
- char absolute_filename[1024];
- struct stat buf;
-
- sprintf(absolute_filename, "%s/%s", path, direntp->d_name);
-
- if (stat(absolute_filename, &buf) == 0 && S_ISDIR(buf.st_mode))
- {
- if(expected_file != NULL)
- {
- sprintf(filename,"%s/%s/%s",path,direntp->d_name,expected_file);
- if(!faccessible(filename))
- continue;
- }
-
- string_list_add_item(&sdirs,direntp->d_name);
- }
- }
- closedir(dirStructP);
- }
-
- sprintf(path,"%s/%s",datadir.c_str(),rel_path);
- if((dirStructP = opendir(path)) != NULL)
- {
- while((direntp = readdir(dirStructP)) != NULL)
- {
- char absolute_filename[1024];
- struct stat buf;
-
- sprintf(absolute_filename, "%s/%s", path, direntp->d_name);
-
- if (stat(absolute_filename, &buf) == 0 && S_ISDIR(buf.st_mode))
- {
- if(expected_file != NULL)
- {
- sprintf(filename,"%s/%s/%s",path,direntp->d_name,expected_file);
- if(!faccessible(filename))
- {
- continue;
- }
- else
- {
- sprintf(filename,"%s/%s/%s/%s",st_dir,rel_path,direntp->d_name,expected_file);
- if(faccessible(filename))
- continue;
- }
- }
-
- string_list_add_item(&sdirs,direntp->d_name);
- }
- }
- closedir(dirStructP);
- }
-
- return sdirs;
-}
-
-string_list_type dfiles(const char *rel_path, const char* glob, const char* exception_str)
-{
- DIR *dirStructP;
- struct dirent *direntp;
- string_list_type sdirs;
- char path[1024];
-
- string_list_init(&sdirs);
- sprintf(path,"%s/%s",st_dir,rel_path);
- if((dirStructP = opendir(path)) != NULL)
- {
- while((direntp = readdir(dirStructP)) != NULL)
- {
- char absolute_filename[1024];
- struct stat buf;
-
- sprintf(absolute_filename, "%s/%s", path, direntp->d_name);
-
- if (stat(absolute_filename, &buf) == 0 && S_ISREG(buf.st_mode))
- {
- if(exception_str != NULL)
- {
- if(strstr(direntp->d_name,exception_str) != NULL)
- continue;
- }
- if(glob != NULL)
- if(strstr(direntp->d_name,glob) == NULL)
- continue;
-
- string_list_add_item(&sdirs,direntp->d_name);
- }
- }
- closedir(dirStructP);
- }
-
- sprintf(path,"%s/%s",datadir.c_str(),rel_path);
- if((dirStructP = opendir(path)) != NULL)
- {
- while((direntp = readdir(dirStructP)) != NULL)
- {
- char absolute_filename[1024];
- struct stat buf;
-
- sprintf(absolute_filename, "%s/%s", path, direntp->d_name);
-
- if (stat(absolute_filename, &buf) == 0 && S_ISREG(buf.st_mode))
- {
- if(exception_str != NULL)
- {
- if(strstr(direntp->d_name,exception_str) != NULL)
- continue;
- }
- if(glob != NULL)
- if(strstr(direntp->d_name,glob) == NULL)
- continue;
-
- string_list_add_item(&sdirs,direntp->d_name);
- }
- }
- closedir(dirStructP);
- }
-
- return sdirs;
-}
-
-void free_strings(char **strings, int num)
-{
- int i;
- for(i=0; i < num; ++i)
- free(strings[i]);
-}
-
-/* --- SETUP --- */
-/* Set SuperTux configuration and save directories */
-void st_directory_setup(void)
-{
- char *home;
- char str[1024];
- /* Get home directory (from $HOME variable)... if we can't determine it,
- use the current directory ("."): */
- if (getenv("HOME") != NULL)
- home = getenv("HOME");
- else
- home = ".";
-
- st_dir = (char *) malloc(sizeof(char) * (strlen(home) +
- strlen("/.supertux") + 1));
- strcpy(st_dir, home);
- strcat(st_dir, "/.supertux");
-
- /* Remove .supertux config-file from old SuperTux versions */
- if(faccessible(st_dir))
- {
- remove
- (st_dir);
- }
-
- st_save_dir = (char *) malloc(sizeof(char) * (strlen(st_dir) + strlen("/save") + 1));
-
- strcpy(st_save_dir,st_dir);
- strcat(st_save_dir,"/save");
-
- /* Create them. In the case they exist they won't destroy anything. */
- mkdir(st_dir, 0755);
- mkdir(st_save_dir, 0755);
-
- sprintf(str, "%s/levels", st_dir);
- mkdir(str, 0755);
-
- // User has not that a datadir, so we try some magic
- if (datadir.empty())
- {
-#ifndef WIN32
- // Detect datadir
- char exe_file[PATH_MAX];
- if (readlink("/proc/self/exe", exe_file, PATH_MAX) < 0)
- {
- puts("Couldn't read /proc/self/exe, using default path: " DATA_PREFIX);
- datadir = DATA_PREFIX;
- }
- else
- {
- std::string exedir = std::string(dirname(exe_file)) + "/";
-
- datadir = exedir + "../data"; // SuperTux run from source dir
- if (access(datadir.c_str(), F_OK) != 0)
- {
- datadir = exedir + "../share/supertux"; // SuperTux run from PATH
- if (access(datadir.c_str(), F_OK) != 0)
- { // If all fails, fall back to compiled path
- datadir = DATA_PREFIX;
- }
- }
- }
-#else
- datadir = DATA_PREFIX;
-#endif
- }
- printf("Datadir: %s\n", datadir.c_str());
-}
-
-/* Create and setup menus. */
-void st_menu(void)
-{
- main_menu = new Menu();
- options_menu = new Menu();
- options_keys_menu = new Menu();
- options_joystick_menu = new Menu();
- load_game_menu = new Menu();
- save_game_menu = new Menu();
- game_menu = new Menu();
- highscore_menu = new Menu();
- contrib_menu = new Menu();
- contrib_subset_menu = new Menu();
- worldmap_menu = new Menu();
-
- main_menu->set_pos(screen->w/2, 335);
- main_menu->additem(MN_GOTO, _("Start Game"),0,load_game_menu, MNID_STARTGAME);
- main_menu->additem(MN_GOTO, _("Contrib Levels"),0,contrib_menu, MNID_LEVELS_CONTRIB);
- main_menu->additem(MN_GOTO, _("Options"),0,options_menu, MNID_OPTIONMENU);
- main_menu->additem(MN_ACTION, _("Level Editor"),0,0, MNID_LEVELEDITOR);
- main_menu->additem(MN_ACTION, _("Credits"),0,0, MNID_CREDITS);
- main_menu->additem(MN_ACTION, _("Quit"),0,0, MNID_QUITMAINMENU);
-
- options_menu->additem(MN_LABEL,_("Options"),0,0);
- options_menu->additem(MN_HL,"",0,0);
-#ifndef NOOPENGL
- options_menu->additem(MN_TOGGLE,_("OpenGL "),use_gl,0, MNID_OPENGL);
-#else
- options_menu->additem(MN_DEACTIVE,_("OpenGL (not supported)"),use_gl, 0, MNID_OPENGL);
-#endif
- options_menu->additem(MN_TOGGLE,_("Fullscreen"),use_fullscreen,0, MNID_FULLSCREEN);
- if(audio_device)
- {
- options_menu->additem(MN_TOGGLE,_("Sound "), use_sound,0, MNID_SOUND);
- options_menu->additem(MN_TOGGLE,_("Music "), use_music,0, MNID_MUSIC);
- }
- else
- {
- options_menu->additem(MN_DEACTIVE,_("Sound "), false,0, MNID_SOUND);
- options_menu->additem(MN_DEACTIVE,_("Music "), false,0, MNID_MUSIC);
- }
- options_menu->additem(MN_TOGGLE,_("Show FPS "),show_fps,0, MNID_SHOWFPS);
- options_menu->additem(MN_GOTO,_("Setup Keys"),0,options_keys_menu);
-
- if(use_joystick)
- options_menu->additem(MN_GOTO,_("Setup Joystick"),0,options_joystick_menu);
-
- options_menu->additem(MN_HL,"",0,0);
- options_menu->additem(MN_BACK,_("Back"),0,0);
-
- options_keys_menu->additem(MN_LABEL,_("Keyboard Setup"),0,0);
- options_keys_menu->additem(MN_HL,"",0,0);
- options_keys_menu->additem(MN_CONTROLFIELD_KB,_("Left move"), 0,0, 0,&keymap.left);
- options_keys_menu->additem(MN_CONTROLFIELD_KB,_("Right move"), 0,0, 0,&keymap.right);
- options_keys_menu->additem(MN_CONTROLFIELD_KB,_("Jump"), 0,0, 0,&keymap.jump);
- options_keys_menu->additem(MN_CONTROLFIELD_KB,_("Duck"), 0,0, 0,&keymap.duck);
- options_keys_menu->additem(MN_CONTROLFIELD_KB,_("Activate"), 0, 0, 0,
- &keymap.activate);
- options_keys_menu->additem(MN_CONTROLFIELD_KB,_("Power/Run"), 0,0, 0,&keymap.fire);
- options_keys_menu->additem(MN_HL,"",0,0);
- options_keys_menu->additem(MN_BACK,_("Back"),0,0);
-
- if(use_joystick)
- {
- options_joystick_menu->additem(MN_LABEL,_("Joystick Setup"),0,0);
- options_joystick_menu->additem(MN_HL,"",0,0);
- //options_joystick_menu->additem(MN_CONTROLFIELD_JS,"X axis", 0,0, 0,&joystick_keymap.x_axis);
- //options_joystick_menu->additem(MN_CONTROLFIELD_JS,"Y axis", 0,0, 0,&joystick_keymap.y_axis);
- options_joystick_menu->additem(MN_CONTROLFIELD_JS,_("A button"), 0,0, 0,&joystick_keymap.a_button);
- options_joystick_menu->additem(MN_CONTROLFIELD_JS,_("B button"), 0,0, 0,&joystick_keymap.b_button);
- //options_joystick_menu->additem(MN_CONTROLFIELD_JS,"Start", 0,0, 0,&joystick_keymap.start_button);
- //options_joystick_menu->additem(MN_CONTROLFIELD_JS,"DeadZone", 0,0, 0,&joystick_keymap.dead_zone);
- options_joystick_menu->additem(MN_HL,"",0,0);
- options_joystick_menu->additem(MN_BACK,_("Back"),0,0);
- }
-
- load_game_menu->additem(MN_LABEL,_("Start Game"),0,0);
- load_game_menu->additem(MN_HL,"",0,0);
- load_game_menu->additem(MN_DEACTIVE,"Slot 1",0,0, 1);
- load_game_menu->additem(MN_DEACTIVE,"Slot 2",0,0, 2);
- load_game_menu->additem(MN_DEACTIVE,"Slot 3",0,0, 3);
- load_game_menu->additem(MN_DEACTIVE,"Slot 4",0,0, 4);
- load_game_menu->additem(MN_DEACTIVE,"Slot 5",0,0, 5);
- load_game_menu->additem(MN_HL,"",0,0);
- load_game_menu->additem(MN_BACK,_("Back"),0,0);
-
- save_game_menu->additem(MN_LABEL,_("Save Game"),0,0);
- save_game_menu->additem(MN_HL,"",0,0);
- save_game_menu->additem(MN_DEACTIVE,"Slot 1",0,0, 1);
- save_game_menu->additem(MN_DEACTIVE,"Slot 2",0,0, 2);
- save_game_menu->additem(MN_DEACTIVE,"Slot 3",0,0, 3);
- save_game_menu->additem(MN_DEACTIVE,"Slot 4",0,0, 4);
- save_game_menu->additem(MN_DEACTIVE,"Slot 5",0,0, 5);
- save_game_menu->additem(MN_HL,"",0,0);
- save_game_menu->additem(MN_BACK,"Back",0,0);
-
- game_menu->additem(MN_LABEL,_("Pause"),0,0);
- game_menu->additem(MN_HL,"",0,0);
- game_menu->additem(MN_ACTION,_("Continue"),0,0,MNID_CONTINUE);
- game_menu->additem(MN_GOTO,_("Options"),0,options_menu);
- game_menu->additem(MN_HL,"",0,0);
- game_menu->additem(MN_ACTION,_("Abort Level"),0,0,MNID_ABORTLEVEL);
-
- worldmap_menu->additem(MN_LABEL,_("Pause"),0,0);
- worldmap_menu->additem(MN_HL,"",0,0);
- worldmap_menu->additem(MN_ACTION,_("Continue"),0,0,MNID_RETURNWORLDMAP);
- worldmap_menu->additem(MN_GOTO,_("Options"),0,options_menu);
- worldmap_menu->additem(MN_HL,"",0,0);
- worldmap_menu->additem(MN_ACTION,_("Quit Game"),0,0,MNID_QUITWORLDMAP);
-
- highscore_menu->additem(MN_TEXTFIELD,_("Enter your name:"),0,0);
-}
-
-void update_load_save_game_menu(Menu* pmenu)
-{
- for(int i = 2; i < 7; ++i)
- {
- // FIXME: Insert a real savegame struct/class here instead of
- // doing string vodoo
- std::string tmp = slotinfo(i - 1);
- pmenu->item[i].kind = MN_ACTION;
- pmenu->item[i].change_text(tmp.c_str());
- }
-}
-
-bool process_load_game_menu()
-{
- int slot = load_game_menu->check();
-
- if(slot != -1 && load_game_menu->get_item_by_id(slot).kind == MN_ACTION)
- {
- char slotfile[1024];
- snprintf(slotfile, 1024, "%s/slot%d.stsg", st_save_dir, slot);
-
- if (access(slotfile, F_OK) != 0)
- {
- draw_intro();
- }
-
- // shrink_fade(Point((screen->w/2),(screen->h/2)), 1000);
- fadeout(256);
- WorldMapNS::WorldMap worldmap;
-
- // Load the game or at least set the savegame_file variable
- worldmap.loadgame(slotfile);
-
- worldmap.display();
-
- Menu::set_current(main_menu);
-
- st_pause_ticks_stop();
- return true;
- }
- else
- {
- return false;
- }
-}
-
-/* Handle changes made to global settings in the options menu. */
-void process_options_menu(void)
-{
- switch (options_menu->check())
- {
- case MNID_OPENGL:
-#ifndef NOOPENGL
- if(use_gl != options_menu->isToggled(MNID_OPENGL))
- {
- use_gl = !use_gl;
- st_video_setup();
- }
-#else
- options_menu->get_item_by_id(MNID_OPENGL).toggled = false;
-#endif
- break;
- case MNID_FULLSCREEN:
- if(use_fullscreen != options_menu->isToggled(MNID_FULLSCREEN))
- {
- use_fullscreen = !use_fullscreen;
- st_video_setup();
- }
- break;
- case MNID_SOUND:
- if(use_sound != options_menu->isToggled(MNID_SOUND))
- use_sound = !use_sound;
- break;
- case MNID_MUSIC:
- if(use_music != options_menu->isToggled(MNID_MUSIC))
- {
- use_music = !use_music;
- sound_manager->enable_music(use_music);
- }
- break;
- case MNID_SHOWFPS:
- if(show_fps != options_menu->isToggled(MNID_SHOWFPS))
- show_fps = !show_fps;
- break;
- }
-}
-
-void st_general_setup(void)
-{
- /* Seed random number generator: */
-
- srand(SDL_GetTicks());
-
- /* Set icon image: */
-
- seticon();
-
- /* Unicode needed for input handling: */
-
- SDL_EnableUNICODE(1);
-
- /* Load global images: */
- gold_text = new Font(datadir + "/images/fonts/gold.png", Font::TEXT, 16,18);
- blue_text = new Font(datadir + "/images/fonts/blue.png", Font::TEXT, 16,18,3);
- white_text = new Font(datadir + "/images/fonts/white.png",
- Font::TEXT, 16,18);
- gray_text = new Font(datadir + "/images/fonts/gray.png",
- Font::TEXT, 16,18);
- white_small_text = new Font(datadir + "/images/fonts/white-small.png",
- Font::TEXT, 8,9, 1);
- white_big_text = new Font(datadir + "/images/fonts/white-big.png",
- Font::TEXT, 20,22, 3);
- yellow_nums = new Font(datadir + "/images/fonts/numbers.png",
- Font::NUM, 32,32);
-
- /* Load GUI/menu images: */
- checkbox = new Surface(datadir + "/images/status/checkbox.png", true);
- checkbox_checked = new Surface(datadir + "/images/status/checkbox-checked.png", true);
- back = new Surface(datadir + "/images/status/back.png", true);
- arrow_left = new Surface(datadir + "/images/icons/left.png", true);
- arrow_right = new Surface(datadir + "/images/icons/right.png", true);
-
- /* Load the mouse-cursor */
- mouse_cursor = new MouseCursor( datadir + "/images/status/mousecursor.png",1);
- MouseCursor::set_current(mouse_cursor);
-
-}
-
-void st_general_free(void)
-{
-
- /* Free global images: */
- delete gold_text;
- delete white_text;
- delete blue_text;
- delete gray_text;
- delete white_small_text;
- delete white_big_text;
- delete yellow_nums;
-
- /* Free GUI/menu images: */
- delete checkbox;
- delete checkbox_checked;
- delete back;
- delete arrow_left;
- delete arrow_right;
-
- /* Free mouse-cursor */
- delete mouse_cursor;
-
- /* Free menus */
- delete main_menu;
- delete game_menu;
- delete options_menu;
- delete options_keys_menu;
- delete options_joystick_menu;
- delete highscore_menu;
- delete contrib_menu;
- delete contrib_subset_menu;
- delete worldmap_menu;
- delete save_game_menu;
- delete load_game_menu;
-}
-
-void st_video_setup(void)
-{
- /* Init SDL Video: */
- if (SDL_Init(SDL_INIT_VIDEO) < 0)
- {
- fprintf(stderr,
- "\nError: I could not initialize video!\n"
- "The Simple DirectMedia error that occured was:\n"
- "%s\n\n", SDL_GetError());
- exit(1);
- }
-
- /* Open display: */
- if(use_gl)
- st_video_setup_gl();
- else
- st_video_setup_sdl();
-
- Surface::reload_all();
-
- /* Set window manager stuff: */
- SDL_WM_SetCaption("SuperTux " VERSION, "SuperTux");
-}
-
-void st_video_setup_sdl(void)
-{
- if (use_fullscreen)
- {
- screen = SDL_SetVideoMode(SCREEN_W, SCREEN_H, 0, SDL_FULLSCREEN ) ; /* | SDL_HWSURFACE); */
- if (screen == NULL)
- {
- fprintf(stderr,
- "\nWarning: I could not set up fullscreen video for "
- "800x600 mode.\n"
- "The Simple DirectMedia error that occured was:\n"
- "%s\n\n", SDL_GetError());
- use_fullscreen = false;
- }
- }
- else
- {
- screen = SDL_SetVideoMode(SCREEN_W, SCREEN_H, 0, SDL_HWSURFACE | SDL_DOUBLEBUF );
-
- if (screen == NULL)
- {
- fprintf(stderr,
- "\nError: I could not set up video for 800x600 mode.\n"
- "The Simple DirectMedia error that occured was:\n"
- "%s\n\n", SDL_GetError());
- exit(1);
- }
- }
-}
-
-void st_video_setup_gl(void)
-{
-#ifndef NOOPENGL
-
- SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
- SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
- SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
- SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
- SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-
- if (use_fullscreen)
- {
- screen = SDL_SetVideoMode(SCREEN_W, SCREEN_H, 0, SDL_FULLSCREEN | SDL_OPENGL) ; /* | SDL_HWSURFACE); */
- if (screen == NULL)
- {
- fprintf(stderr,
- "\nWarning: I could not set up fullscreen video for "
- "640x480 mode.\n"
- "The Simple DirectMedia error that occured was:\n"
- "%s\n\n", SDL_GetError());
- use_fullscreen = false;
- }
- }
- else
- {
- screen = SDL_SetVideoMode(SCREEN_W, SCREEN_H, 0, SDL_OPENGL);
-
- if (screen == NULL)
- {
- fprintf(stderr,
- "\nError: I could not set up video for 640x480 mode.\n"
- "The Simple DirectMedia error that occured was:\n"
- "%s\n\n", SDL_GetError());
- exit(1);
- }
- }
-
- /*
- * Set up OpenGL for 2D rendering.
- */
- glDisable(GL_DEPTH_TEST);
- glDisable(GL_CULL_FACE);
-
- glViewport(0, 0, screen->w, screen->h);
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- glOrtho(0, screen->w, screen->h, 0, -1.0, 1.0);
-
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
- glTranslatef(0.0f, 0.0f, 0.0f);
-
-#endif
-
-}
-
-void st_joystick_setup(void)
-{
-
- /* Init Joystick: */
-
- use_joystick = true;
-
- if (SDL_Init(SDL_INIT_JOYSTICK) < 0)
- {
- fprintf(stderr, "Warning: I could not initialize joystick!\n"
- "The Simple DirectMedia error that occured was:\n"
- "%s\n\n", SDL_GetError());
-
- use_joystick = false;
- }
- else
- {
- /* Open joystick: */
- if (SDL_NumJoysticks() <= 0)
- {
- fprintf(stderr, "Info: No joysticks were found.\n");
-
- use_joystick = false;
- }
- else
- {
- js = SDL_JoystickOpen(joystick_num);
-
- if (js == NULL)
- {
- fprintf(stderr, "Warning: Could not open joystick %d.\n"
- "The Simple DirectMedia error that occured was:\n"
- "%s\n\n", joystick_num, SDL_GetError());
-
- use_joystick = false;
- }
- else
- {
- if (SDL_JoystickNumAxes(js) < 2)
- {
- fprintf(stderr,
- "Warning: Joystick does not have enough axes!\n");
-
- use_joystick = false;
- }
- else
- {
- if (SDL_JoystickNumButtons(js) < 2)
- {
- fprintf(stderr,
- "Warning: "
- "Joystick does not have enough buttons!\n");
-
- use_joystick = false;
- }
- }
- }
- }
- }
-}
-
-void st_audio_setup(void)
-{
-
- /* Init SDL Audio silently even if --disable-sound : */
-
- if (audio_device)
- {
- if (SDL_Init(SDL_INIT_AUDIO) < 0)
- {
- /* only print out message if sound or music
- was not disabled at command-line
- */
- if (use_sound || use_music)
- {
- fprintf(stderr,
- "\nWarning: I could not initialize audio!\n"
- "The Simple DirectMedia error that occured was:\n"
- "%s\n\n", SDL_GetError());
- }
- /* keep the programming logic the same :-)
- because in this case, use_sound & use_music' values are ignored
- when there's no available audio device
- */
- use_sound = false;
- use_music = false;
- audio_device = false;
- }
- }
-
-
- /* Open sound silently regarless the value of "use_sound": */
-
- if (audio_device)
- {
- if (open_audio(44100, AUDIO_S16, 2, 2048) < 0)
- {
- /* only print out message if sound or music
- was not disabled at command-line
- */
- if (use_sound || use_music)
- {
- fprintf(stderr,
- "\nWarning: I could not set up audio for 44100 Hz "
- "16-bit stereo.\n"
- "The Simple DirectMedia error that occured was:\n"
- "%s\n\n", SDL_GetError());
- }
- use_sound = false;
- use_music = false;
- audio_device = false;
- }
- }
-
-}
-
-
-/* --- SHUTDOWN --- */
-
-void st_shutdown(void)
-{
- close_audio();
- SDL_Quit();
- saveconfig();
-}
-
-/* --- ABORT! --- */
-
-void st_abort(const std::string& reason, const std::string& details)
-{
- fprintf(stderr, "\nError: %s\n%s\n\n", reason.c_str(), details.c_str());
- st_shutdown();
- abort();
-}
-
-/* Set Icon (private) */
-
-void seticon(void)
-{
-// int masklen;
-// Uint8 * mask;
- SDL_Surface * icon;
-
-
- /* Load icon into a surface: */
-
- icon = IMG_Load((datadir + "/images/supertux.xpm").c_str());
- if (icon == NULL)
- {
- fprintf(stderr,
- "\nError: I could not load the icon image: %s%s\n"
- "The Simple DirectMedia error that occured was:\n"
- "%s\n\n", datadir.c_str(), "/images/supertux.xpm", SDL_GetError());
- exit(1);
- }
-
-
- /* Create mask: */
-/*
- masklen = (((icon -> w) + 7) / 8) * (icon -> h);
- mask = (Uint8*) malloc(masklen * sizeof(Uint8));
- memset(mask, 0xFF, masklen);
-*/
-
- /* Set icon: */
-
- SDL_WM_SetIcon(icon, NULL);//mask);
-
-
- /* Free icon surface & mask: */
-
-// free(mask);
- SDL_FreeSurface(icon);
-}
-
-
-/* Parse command-line arguments: */
-
-void parseargs(int argc, char * argv[])
-{
- int i;
-
- loadconfig();
-
- /* Parse arguments: */
-
- for (i = 1; i < argc; i++)
- {
- if (strcmp(argv[i], "--fullscreen") == 0 ||
- strcmp(argv[i], "-f") == 0)
- {
- use_fullscreen = true;
- }
- else if (strcmp(argv[i], "--window") == 0 ||
- strcmp(argv[i], "-w") == 0)
- {
- use_fullscreen = false;
- }
- else if (strcmp(argv[i], "--joystick") == 0 || strcmp(argv[i], "-j") == 0)
- {
- assert(i+1 < argc);
- joystick_num = atoi(argv[++i]);
- }
- else if (strcmp(argv[i], "--joymap") == 0)
- {
- assert(i+1 < argc);
- if (sscanf(argv[++i],
- "%d:%d:%d:%d:%d",
- &joystick_keymap.x_axis,
- &joystick_keymap.y_axis,
- &joystick_keymap.a_button,
- &joystick_keymap.b_button,
- &joystick_keymap.start_button) != 5)
- {
- puts("Warning: Invalid or incomplete joymap, should be: 'XAXIS:YAXIS:A:B:START'");
- }
- else
- {
- std::cout << "Using new joymap:\n"
- << " X-Axis: " << joystick_keymap.x_axis << "\n"
- << " Y-Axis: " << joystick_keymap.y_axis << "\n"
- << " A-Button: " << joystick_keymap.a_button << "\n"
- << " B-Button: " << joystick_keymap.b_button << "\n"
- << " Start-Button: " << joystick_keymap.start_button << std::endl;
- }
- }
- else if (strcmp(argv[i], "--leveleditor") == 0)
- {
- launch_leveleditor_mode = true;
- }
- else if (strcmp(argv[i], "--worldmap") == 0)
- {
- launch_worldmap_mode = true;
- }
- else if (strcmp(argv[i], "--datadir") == 0
- || strcmp(argv[i], "-d") == 0 )
- {
- assert(i+1 < argc);
- datadir = argv[++i];
- }
- else if (strcmp(argv[i], "--show-fps") == 0)
- {
- /* Use full screen: */
-
- show_fps = true;
- }
- else if (strcmp(argv[i], "--opengl") == 0 ||
- strcmp(argv[i], "-gl") == 0)
- {
-#ifndef NOOPENGL
- /* Use OpengGL: */
-
- use_gl = true;
-#endif
- }
- else if (strcmp(argv[i], "--sdl") == 0)
- {
- use_gl = false;
- }
- else if (strcmp(argv[i], "--usage") == 0)
- {
- /* Show usage: */
-
- usage(argv[0], 0);
- }
- else if (strcmp(argv[i], "--version") == 0)
- {
- /* Show version: */
- printf("SuperTux " VERSION "\n");
- exit(0);
- }
- else if (strcmp(argv[i], "--disable-sound") == 0)
- {
- /* Disable the compiled in sound feature */
- printf("Sounds disabled \n");
- use_sound = false;
- audio_device = false;
- }
- else if (strcmp(argv[i], "--disable-music") == 0)
- {
- /* Disable the compiled in sound feature */
- printf("Music disabled \n");
- use_music = false;
- }
- else if (strcmp(argv[i], "--debug") == 0)
- {
- /* Enable the debug-mode */
- debug_mode = true;
-
- }
- else if (strcmp(argv[i], "--help") == 0)
- { /* Show help: */
- puts(_(" SuperTux " VERSION "\n"
- " Please see the file \"README.txt\" for more details.\n"));
- printf(_("Usage: %s [OPTIONS] FILENAME\n\n"), argv[0]);
- puts(_("Display Options:\n"
- " -f, --fullscreen Run in fullscreen mode.\n"
- " -w, --window Run in window mode.\n"
- " --opengl If OpenGL support was compiled in, this will tell\n"
- " SuperTux to make use of it.\n"
- " --sdl Use the SDL software graphical renderer\n"
- "\n"
- "Sound Options:\n"
- " --disable-sound If sound support was compiled in, this will\n"
- " disable sound for this session of the game.\n"
- " --disable-music Like above, but this will disable music.\n"
- "\n"
- "Misc Options:\n"
- " -j, --joystick NUM Use joystick NUM (default: 0)\n"
- " --joymap XAXIS:YAXIS:A:B:START\n"
- " Define how joystick buttons and axis should be mapped\n"
- " --leveleditor Opens the leveleditor in a file.\n"
- " --worldmap Opens the specified worldmap file.\n"
- " -d, --datadir DIR Load Game data from DIR (default: automatic)\n"
- " --debug Enables the debug mode, which is useful for developers.\n"
- " --help Display a help message summarizing command-line\n"
- " options, license and game controls.\n"
- " --usage Display a brief message summarizing command-line options.\n"
- " --version Display the version of SuperTux you're running.\n\n"
- ));
- exit(0);
- }
- else if (argv[i][0] != '-')
- {
- level_startup_file = argv[i];
- }
- else
- {
- /* Unknown - complain! */
-
- usage(argv[0], 1);
- }
- }
-}
-
-
-/* Display usage: */
-
-void usage(char * prog, int ret)
-{
- FILE * fi;
-
-
- /* Determine which stream to write to: */
-
- if (ret == 0)
- fi = stdout;
- else
- fi = stderr;
-
-
- /* Display the usage message: */
-
- fprintf(fi, _("Usage: %s [--fullscreen] [--opengl] [--disable-sound] [--disable-music] [--debug] | [--usage | --help | --version] [--leveleditor] [--worldmap] FILENAME\n"),
- prog);
-
-
- /* Quit! */
-
- exit(ret);
-}
-
-std::vector<std::string> read_directory(const std::string& pathname)
-{
- std::vector<std::string> dirnames;
-
- DIR* dir = opendir(pathname.c_str());
- if (dir)
- {
- struct dirent *direntp;
-
- while((direntp = readdir(dir)))
- {
- dirnames.push_back(direntp->d_name);
- }
-
- closedir(dir);
- }
-
- return dirnames;
-}
-
-/* EOF */
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2000 Bill Kendrick <bill@newbreedsoftware.com>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#ifndef SUPERTUX_SETUP_H
-#define SUPERTUX_SETUP_H
-
-#include <vector>
-#include <string>
-#include "menu.h"
-#include "sound.h"
-#include "type.h"
-
-int faccessible(const char *filename);
-int fcreatedir(const char* relative_dir);
-int fwriteable(const char *filename);
-std::vector<std::string> read_directory(const std::string& pathname);
-
-FILE * opendata(const char * filename, const char * mode);
-string_list_type dsubdirs(const char *rel_path, const char* expected_file);
-string_list_type dfiles(const char *rel_path, const char* glob, const char* exception_str);
-void free_strings(char **strings, int num);
-void st_directory_setup(void);
-void st_general_setup(void);
-void st_general_free();
-void st_video_setup_sdl(void);
-void st_video_setup_gl(void);
-void st_video_setup(void);
-void st_audio_setup(void);
-void st_joystick_setup(void);
-void st_shutdown(void);
-void st_menu(void);
-void st_abort(const std::string& reason, const std::string& details);
-void process_options_menu(void);
-
-/** Return true if the gameloop() was entered, false otherwise */
-bool process_load_game_menu();
-
-void update_load_save_game_menu(Menu* pmenu);
-void parseargs(int argc, char * argv[]);
-
-#endif /*SUPERTUX_SETUP_H*/
-
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2000 Bill Kendrick <bill@newbreedsoftware.com>
-// Copyright (C) 2004 Duong-Khang NGUYEN <neoneurone@users.sf.net>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#include "defines.h"
-#include "globals.h"
-#include "sound.h"
-#include "setup.h"
-
-/*global variable*/
-bool use_sound = true; /* handle sound on/off menu and command-line option */
-bool use_music = true; /* handle music on/off menu and command-line option */
-bool audio_device = true; /* != 0: available and initialized */
-
-char * soundfilenames[NUM_SOUNDS] = {
- "/sounds/jump.wav",
- "/sounds/bigjump.wav",
- "/sounds/skid.wav",
- "/sounds/coin.wav",
- "/sounds/invincible.wav",
- "/sounds/brick.wav",
- "/sounds/hurt.wav",
- "/sounds/squish.wav",
- "/sounds/fall.wav",
- "/sounds/ricochet.wav",
- "/sounds/bump-upgrade.wav",
- "/sounds/upgrade.wav",
- "/sounds/grow.wav",
- "/sounds/fire-flower.wav",
- "/sounds/shoot.wav",
- "/sounds/lifeup.wav",
- "/sounds/stomp.wav",
- "/sounds/kick.wav",
- "/sounds/explosion.wav"
- };
-
-
-#include <SDL_mixer.h>
-
-Mix_Chunk * sounds[NUM_SOUNDS];
-
-/* --- OPEN THE AUDIO DEVICE --- */
-
-int open_audio (int frequency, Uint16 format, int channels, int chunksize)
-{
- if (Mix_OpenAudio( frequency, format, channels, chunksize ) < 0)
- return -1;
-
- // allocate 16 channels for mixing
- if (Mix_AllocateChannels(8) != 8)
- return -2;
-
- return 0;
-}
-
-
-/* --- CLOSE THE AUDIO DEVICE --- */
-
-void close_audio( void )
-{
- if (audio_device) {
- Mix_CloseAudio();
- }
-}
-
-
-/* --- LOAD A SOUND --- */
-
-Mix_Chunk* load_sound(const std::string& file)
-{
- if(!audio_device)
- return 0;
-
- Mix_Chunk* snd = Mix_LoadWAV(file.c_str());
-
- if (snd == 0)
- st_abort("Can't load", file);
-
- return(snd);
-}
-
-void free_chunk(Mix_Chunk *chunk)
-{
- Mix_FreeChunk( chunk );
-}
-
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2000 Bill Kendrick <bill@newbreedsoftware.com>
-// Copyright (C) 2004 Duong-Khang NGUYEN <neoneurone@users.sf.net>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#ifndef SUPERTUX_SOUND_H
-#define SUPERTUX_SOUND_H
-
-#include "defines.h" /* get YES/NO defines */
-
-/*global variable*/
-extern bool use_sound; /* handle sound on/off menu and command-line option */
-extern bool use_music; /* handle music on/off menu and command-line */
-extern bool audio_device; /* != 0: available and initialized */
-
-/* enum of different internal music types */
-enum Music_Type {
- NO_MUSIC,
- LEVEL_MUSIC,
- HURRYUP_MUSIC,
- HERRING_MUSIC
-};
-
-/* Sound files: */
-enum {
- SND_JUMP,
- SND_BIGJUMP,
- SND_SKID,
- SND_DISTRO,
- SND_HERRING,
- SND_BRICK,
- SND_HURT,
- SND_SQUISH,
- SND_FALL,
- SND_RICOCHET,
- SND_BUMP_UPGRADE,
- SND_UPGRADE,
- SND_EXCELLENT,
- SND_COFFEE,
- SND_SHOOT,
- SND_LIFEUP,
- SND_STOMP,
- SND_KICK,
- SND_EXPLODE,
- NUM_SOUNDS
-};
-
-extern char* soundfilenames[NUM_SOUNDS];
-
-#include <string>
-#include <SDL_mixer.h>
-
-/* variables for stocking the sound and music */
-extern Mix_Chunk* sounds[NUM_SOUNDS];
-
-/* functions handling the sound and music */
-int open_audio(int frequency, Uint16 format, int channels, int chunksize);
-void close_audio( void );
-
-Mix_Chunk * load_sound(const std::string& file);
-void free_chunk(Mix_Chunk*chunk);
-
-#endif /*SUPERTUX_SOUND_H*/
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2004 Matthias Braun <matze@braunis.de
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#include <cmath>
-#include <cassert>
-
-#include "sound_manager.h"
-#include "musicref.h"
-#include "setup.h"
-#include "sector.h"
-#include "camera.h"
-#include "sound.h"
-#include "globals.h"
-#include "moving_object.h"
-
-SoundManager::SoundManager()
- : current_music(0), music_enabled(true)
-{
-}
-
-SoundManager::~SoundManager()
-{
- if(audio_device)
- Mix_HaltMusic();
-}
-
-void
-SoundManager::play_sound(Mix_Chunk* sound)
-{
- if(!audio_device || !use_sound)
- return;
-
- Mix_PlayChannel(-1, sound, 0);
-}
-
-void
-SoundManager::play_sound(Mix_Chunk* sound, const MovingObject* object)
-{
- // TODO keep track of the object later and move the sound along with the
- // object.
- play_sound(sound, object->get_pos());
-}
-
-void
-SoundManager::play_sound(Mix_Chunk* sound, const Vector& pos)
-{
- if(!audio_device || !use_sound)
- return;
-
- // TODO make sure this formula is good
- float distance
- = Sector::current()->player->get_pos().x - pos.x;
- int loud = int(255.0/float(screen->w*2) * fabsf(distance));
- if(loud > 255)
- return;
-
- int chan = Mix_PlayChannel(-1, sound, 0);
- if(chan < 0)
- return;
- Mix_SetDistance(chan, loud);
-
- // very bad way to do this...
- if(distance > 100)
- Mix_SetPanning(chan, 230, 24);
- else if(distance < -100)
- Mix_SetPanning(chan, 24, 230);
-}
-
-MusicRef
-SoundManager::load_music(const std::string& file)
-{
- if(!audio_device)
- return MusicRef(0);
-
- if(!exists_music(file))
- st_abort("Couldn't load musicfile ", file.c_str());
-
- std::map<std::string, MusicResource>::iterator i = musics.find(file);
- assert(i != musics.end());
- return MusicRef(& (i->second));
-}
-
-bool
-SoundManager::exists_music(const std::string& file)
-{
- if(!audio_device)
- return true;
-
- // song already loaded?
- std::map<std::string, MusicResource>::iterator i = musics.find(file);
- if(i != musics.end()) {
- return true;
- }
-
- Mix_Music* song = Mix_LoadMUS(file.c_str());
- if(song == 0)
- return false;
-
- // insert into music list
- std::pair<std::map<std::string, MusicResource>::iterator, bool> result =
- musics.insert(
- std::make_pair<std::string, MusicResource> (file, MusicResource()));
- MusicResource& resource = result.first->second;
- resource.manager = this;
- resource.music = song;
-
- return true;
-}
-
-void
-SoundManager::free_music(MusicResource* )
-{
- // TODO free music, currently we can't do this since SDL_mixer seems to have
- // some bugs if you load/free alot of mod files.
-}
-
-void
-SoundManager::play_music(const MusicRef& musicref, int loops)
-{
- if(!audio_device)
- return;
-
- if(musicref.music == 0 || current_music == musicref.music)
- return;
-
- if(current_music)
- current_music->refcount--;
-
- current_music = musicref.music;
- current_music->refcount++;
-
- if(music_enabled)
- Mix_PlayMusic(current_music->music, loops);
-}
-
-void
-SoundManager::halt_music()
-{
- if(!audio_device)
- return;
-
- Mix_HaltMusic();
-
- if(current_music) {
- current_music->refcount--;
- if(current_music->refcount == 0)
- free_music(current_music);
- current_music = 0;
- }
-}
-
-void
-SoundManager::enable_music(bool enable)
-{
- if(!audio_device)
- return;
-
- if(enable == music_enabled)
- return;
-
- music_enabled = enable;
- if(music_enabled == false) {
- Mix_HaltMusic();
- } else {
- Mix_PlayMusic(current_music->music, -1);
- }
-}
-
-SoundManager::MusicResource::~MusicResource()
-{
- // don't free music buggy SDL_Mixer crashs for some mod files
- // Mix_FreeMusic(music);
-}
-
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2004 Matthias Braun <matze@braunis.de
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#ifndef SUPERTUX_SOUND_MANAGER_H
-#define SUPERTUX_SOUND_MANAGER_H
-
-#include <string>
-#include <map>
-
-#include "SDL_mixer.h"
-
-#include "vector.h"
-
-class MusicRef;
-class MovingObject;
-
-/** This class handles all sounds that are played
- */
-class SoundManager
-{
-public:
- SoundManager();
- ~SoundManager();
-
- void play_sound(Mix_Chunk* sound);
- void play_sound(Mix_Chunk* sound, const Vector& pos);
- void play_sound(Mix_Chunk* sound, const MovingObject* object);
-
- MusicRef load_music(const std::string& file);
- bool exists_music(const std::string& filename);
-
- void play_music(const MusicRef& music, int loops = -1);
- void halt_music();
-
- void enable_music(bool enable);
-
-private:
- // music part
- friend class MusicRef;
- class MusicResource
- {
- public:
- ~MusicResource();
-
- SoundManager* manager;
- Mix_Music* music;
- int refcount;
- };
-
- void free_music(MusicResource* music);
-
- std::map<std::string, MusicResource> musics;
- MusicResource* current_music;
- bool music_enabled;
-};
-
-#endif /*SUPERTUX_SOUND_MANAGER_H*/
-
+++ /dev/null
-// $Id$
-//
-// SuperTux
-// Copyright (C) 2004 Ingo Ruhnke <grumbel@gmx.de>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#include <iostream>
-#include <cmath>
-
-#include "globals.h"
-#include "sprite.h"
-#include "setup.h"
-#include "screen/drawing_context.h"
-
-Sprite::Sprite(lisp_object_t* cur)
-{
- init_defaults();
-
- LispReader reader(cur);
-
- if(!reader.read_string("name", name))
- st_abort("Sprite wihtout name", "");
- reader.read_int("x-hotspot", x_hotspot);
- reader.read_int("y-hotspot", y_hotspot);
- reader.read_float("fps", fps);
-
- std::vector<std::string> images;
- if(!reader.read_string_vector("images", images))
- st_abort("Sprite contains no images: ", name.c_str());
-
- for(std::vector<std::string>::size_type i = 0; i < images.size(); ++i)
- {
- surfaces.push_back(
- new Surface(datadir + "/images/" + images[i], true));
- }
-
- frame_delay = 1000.0f/fps;
-}
-
-Sprite::~Sprite()
-{
- for(std::vector<Surface*>::iterator i = surfaces.begin(); i != surfaces.end();
- ++i)
- delete *i;
-}
-
-void
-Sprite::init_defaults()
-{
- x_hotspot = 0;
- y_hotspot = 0;
- fps = 10;
- time = 0;
- frame_delay = 1000.0f/fps;
-}
-
-void
-Sprite::update(float /*delta*/)
-{
- //time += 10*delta;
- //std::cout << "Delta: " << delta << std::endl;
-}
-
-void
-Sprite::draw(DrawingContext& context, const Vector& pos, int layer,
- Uint32 drawing_effect)
-{
- time = SDL_GetTicks();
- unsigned int frame = get_current_frame();
-
- if (frame < surfaces.size())
- {
- Surface* surface = surfaces[frame];
-
- context.draw_surface(surface, pos - Vector(x_hotspot, y_hotspot), layer, drawing_effect);
- }
-}
-
-#if 0
-void
-Sprite::draw_part(float sx, float sy, float x, float y, float w, float h)
-{
- time = SDL_GetTicks();
- unsigned int frame = get_current_frame();
-
- if (frame < surfaces.size())
- surfaces[frame]->draw_part(sx, sy, x - x_hotspot, y - y_hotspot, w, h);
-}
-#endif
-
-void
-Sprite::reset()
-{
- time = 0;
-}
-
-int
-Sprite::get_current_frame() const
-{
- unsigned int frame = static_cast<int>(fmodf(time, surfaces.size()*frame_delay)/frame_delay);
- return frame % surfaces.size();
-}
-
-int
-Sprite::get_width() const
-{
- return surfaces[get_current_frame()]->w;
-}
-
-int
-Sprite::get_height() const
-{
- return surfaces[get_current_frame()]->h;
-}
-
-/* EOF */
+++ /dev/null
-// $Id$
-//
-// SuperTux
-// Copyright (C) 2004 Ingo Ruhnke <grumbel@gmx.de>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#ifndef SUPERTUX_SPRITE_H
-#define SUPERTUX_SPRITE_H
-
-#include <string>
-#include <vector>
-
-#include "lispreader.h"
-#include "screen/surface.h"
-#include "vector.h"
-
-class Sprite
-{
- private:
- std::string name;
-
- int x_hotspot;
- int y_hotspot;
-
- /** Frames per second */
- float fps;
-
- /** Number of seconds that a frame is displayed until it is switched
- to the next frame */
- float frame_delay;
-
- float time;
-
- std::vector<Surface*> surfaces;
-
- void init_defaults();
- public:
- /** cur has to be a pointer to data in the form of ((x-hotspot 5)
- (y-hotspot 10) ...) */
- Sprite(lisp_object_t* cur);
- ~Sprite();
-
- void reset();
-
- /** Update the sprite and process to the next frame */
- void update(float delta);
- void draw(DrawingContext& context, const Vector& pos, int layer,
- Uint32 drawing_effect = NONE_EFFECT);
- int get_current_frame() const;
-
- float get_fps() { return fps; } ;
- int get_frames() { return surfaces.size(); } ;
-
- std::string get_name() const { return name; }
- int get_width() const;
- int get_height() const;
-
- Surface* get_frame(unsigned int frame)
- { if(frame < surfaces.size()) return surfaces[frame];
- else return surfaces[0]; }
-};
-
-#endif /*SUPERTUX_SPRITE_H*/
-
-/* Local Variables: */
-/* mode:c++ */
-/* End: */
+++ /dev/null
-// $Id$
-//
-// SuperTux
-// Copyright (C) 2004 Ingo Ruhnke <grumbel@gmx.de>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#include <iostream>
-
-#include "lispreader.h"
-#include "sprite_manager.h"
-
-SpriteManager::SpriteManager(const std::string& filename)
-{
- load_resfile(filename);
-}
-
-SpriteManager::~SpriteManager()
-{
- for(std::map<std::string, Sprite*>::iterator i = sprites.begin();
- i != sprites.end(); ++i) {
- delete i->second;
- }
-}
-
-void
-SpriteManager::load_resfile(const std::string& filename)
-{
- lisp_object_t* root_obj = lisp_read_from_file(filename);
- if (!root_obj)
- {
- std::cout << "SpriteManager: Couldn't load: " << filename << std::endl;
- return;
- }
-
- lisp_object_t* cur = root_obj;
-
- if (strcmp(lisp_symbol(lisp_car(cur)), "supertux-resources") != 0)
- return;
- cur = lisp_cdr(cur);
-
- while(cur)
- {
- lisp_object_t* el = lisp_car(cur);
-
- if (strcmp(lisp_symbol(lisp_car(el)), "sprite") == 0)
- {
- Sprite* sprite = new Sprite(lisp_cdr(el));
-
- Sprites::iterator i = sprites.find(sprite->get_name());
- if (i == sprites.end())
- {
- sprites[sprite->get_name()] = sprite;
- }
- else
- {
- delete i->second;
- i->second = sprite;
- std::cout << "Warning: dulpicate entry: '" << sprite->get_name() << "'" << std::endl;
- }
- }
- else
- {
- std::cout << "SpriteManager: Unknown tag" << std::endl;
- }
-
- cur = lisp_cdr(cur);
- }
-
- lisp_free(root_obj);
-}
-
-Sprite*
-SpriteManager::load(const std::string& name)
-{
- Sprites::iterator i = sprites.find(name);
- if (i != sprites.end())
- {
- return i->second;
- }
- else
- {
- std::cout << "SpriteManager: Sprite '" << name << "' not found" << std::endl;
- return 0;
- }
-}
-
-/* EOF */
+++ /dev/null
-// $Id$
-//
-// SuperTux
-// Copyright (C) 2004 Ingo Ruhnke <grumbel@gmx.de>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#ifndef SUPERTUX_SPRITE_MANAGER_H
-#define SUPERTUX_SPRITE_MANAGER_H
-
-#include <map>
-
-#include "sprite.h"
-
-class SpriteManager
-{
- private:
- typedef std::map<std::string, Sprite*> Sprites;
- Sprites sprites;
- public:
- SpriteManager(const std::string& filename);
- ~SpriteManager();
-
- void load_resfile(const std::string& filename);
- /** loads a sprite.
- * WARNING: You must not delete the returned object.
- */
- Sprite* load(const std::string& name);
-};
-
-#endif /*SUPERTUX_SPRITE_MANAGER_H*/
-
-/* Local Variables: */
-/* mode:c++ */
-/* End: */
+++ /dev/null
-// $Id$
-//
-// SuperTux
-// Copyright (C) 2004 Tobias Glaesser <tobi.web@gmx.de>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-// 02111-1307, USA.
-
-#include "SDL_image.h"
-
-#include "string.h"
-#include "stdlib.h"
-#include "setup.h"
-#include "globals.h"
-#include "screen/screen.h"
-#include "defines.h"
-#include "type.h"
-#include "scene.h"
-
-void string_list_init(string_list_type* pstring_list)
-{
- pstring_list->num_items = 0;
- pstring_list->active_item = -1;
- pstring_list->item = NULL;
-}
-
-char* string_list_active(string_list_type* pstring_list)
-{
- if(pstring_list == NULL)
- return "";
-
- if(pstring_list->active_item != -1)
- return pstring_list->item[pstring_list->active_item];
- else
- return "";
-}
-
-void string_list_add_item(string_list_type* pstring_list,const char* str)
-{
- char *pnew_string;
- pnew_string = (char*) malloc(sizeof(char)*(strlen(str)+1));
- strcpy(pnew_string,str);
- ++pstring_list->num_items;
- pstring_list->item = (char**) realloc(pstring_list->item,sizeof(char**)*pstring_list->num_items);
- pstring_list->item[pstring_list->num_items-1] = pnew_string;
- if(pstring_list->active_item == -1)
- pstring_list->active_item = 0;
-}
-
-void string_list_copy(string_list_type* pstring_list, string_list_type pstring_list_orig)
-{
- int i;
- string_list_free(pstring_list);
- for(i = 0; i < pstring_list_orig.num_items; ++i)
- string_list_add_item(pstring_list,pstring_list_orig.item[i]);
-}
-
-int string_list_find(string_list_type* pstring_list,const char* str)
-{
- int i;
- for(i = 0; i < pstring_list->num_items; ++i)
- {
- if(strcmp(pstring_list->item[i],str) == 0)
- {
- return i;
- }
- }
- return -1;
-}
-
-void string_list_sort(string_list_type* pstring_list)
-{
- int i,j,y;
-
- for(j = 0; j < pstring_list->num_items; ++j)
- for(i = 0; i < pstring_list->num_items-1; ++i)
- {
-
- y = strcmp(pstring_list->item[i],pstring_list->item[i+1]);
- if(y == 0)
- {
- continue;
- }
- else if(y < 0)
- {
- continue;
- }
- else if(y > 0)
- {
- char* char_pointer;
- char_pointer = pstring_list->item[i];
- pstring_list->item[i] = pstring_list->item[i+1];
- pstring_list->item[i+1] = char_pointer;
- continue;
- }
-
- }
-
-}
-
-void string_list_free(string_list_type* pstring_list)
-{
- if(pstring_list != NULL)
- {
- int i;
- for(i=0; i < pstring_list->num_items; ++i)
- free(pstring_list->item[i]);
- free(pstring_list->item);
- pstring_list->item = NULL;
- pstring_list->num_items = 0;
- pstring_list->active_item = -1;
- }
-}
+++ /dev/null
-// $Id$
-//
-// SuperTux
-// Copyright (C) 2004 Tobias Glaesser <tobi.web@gmx.de>
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-// 02111-1307, USA.
-
-#ifndef SUPERTUX_TYPE_H
-#define SUPERTUX_TYPE_H
-
-#include <string>
-
-#include "SDL.h"
-
-#include "scene.h"
-
-/* 'Base' type for game objects */
-
-struct base_type
-{
- float x;
- float y;
- float width;
- float height;
-};
-
-struct string_list_type
-{
- int num_items;
- int active_item;
- char **item;
-};
-
-void string_list_init(string_list_type* pstring_list);
-char* string_list_active(string_list_type* pstring_list);
-void string_list_copy(string_list_type* pstring_list, string_list_type pstring_list_orig);
-int string_list_find(string_list_type* pstring_list, const char* str);
-void string_list_sort(string_list_type* pstring_list);
-void string_list_add_item(string_list_type* pstring_list, const char* str);
-void string_list_free(string_list_type* pstring_list);
-
-
-
-#endif /*SUPERTUX_TYPE_H*/
-
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2004 Matthias Braun <matze@braunis.de
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#include <cmath>
-
-#include "vector.h"
-
-Vector Vector::unit() const
-{
- return *this / norm();
-}
-
-float Vector::norm() const
-{
- return sqrt(x*x + y*y);
-}
+++ /dev/null
-// $Id$
-//
-// SuperTux - A Jump'n Run
-// Copyright (C) 2004 Matthias Braun <matze@braunis.de
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License
-// as published by the Free Software Foundation; either version 2
-// of the License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#ifndef SUPERTUX_VECTOR_H
-#define SUPERTUX_VECTOR_H
-
-class Vector
-{
-public:
- Vector(float nx, float ny)
- : x(nx), y(ny)
- { }
- Vector(const Vector& other)
- : x(other.x), y(other.y)
- { }
- Vector()
- : x(0), y(0)
- { }
-
- bool operator ==(const Vector& other) const
- {
- return x == other.x && y == other.y;
- }
-
- const Vector& operator=(const Vector& other)
- {
- x = other.x;
- y = other.y;
- return *this;
- }
-
- Vector operator+(const Vector& other) const
- {
- return Vector(x + other.x, y + other.y);
- }
-
- Vector operator-(const Vector& other) const
- {
- return Vector(x - other.x, y - other.y);
- }
-
- Vector operator*(float s) const
- {
- return Vector(x * s, y * s);
- }
-
- Vector operator/(float s) const
- {
- return Vector(x / s, y / s);
- }
-
- Vector operator-() const
- {
- return Vector(-x, -y);
- }
-
- const Vector& operator +=(const Vector& other)
- {
- x += other.x;
- y += other.y;
- return *this;
- }
-
- // scalar product of 2 vectors
- float operator*(const Vector& other) const
- {
- return x*other.x + y*other.y;
- }
-
- float norm() const;
- Vector unit() const;
-
- // ... add the other operators as needed, I'm too lazy now ...
-
- float x, y; // leave this public, get/set methods just give me headaches
- // for such simple stuff :)
-};
-
-#endif /*SUPERTUX_VECTOR_H*/
-
projects / supertux.git / commitdiff