X-Git-Url: https://git.octo.it/?a=blobdiff_plain;ds=sidebyside;f=src%2Fmain.cpp;h=1ab47a71612c3b8f28d27dc5059d403db7e713fa;hb=fc73efa7ff699fe3c9c237845b6f4fda0d999862;hp=c1364da12cb53cb4173b1c7cf791dc6de540a306;hpb=c0093d25093395cb62fc2526ab42be65a9f015b8;p=supertux.git

diff --git a/src/main.cpp b/src/main.cpp
index c1364da12..1ab47a716 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,7 +1,7 @@
 //  $Id$
-// 
+//
 //  SuperTux
-//  Copyright (C) 2005 Matthias Braun <matze@braunis.de>
+//  Copyright (C) 2006 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
@@ -12,18 +12,18 @@
 //  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 <config.h>
+#include <assert.h>
 
-#include "main.h"
+#include "log.hpp"
+#include "main.hpp"
 
 #include <stdexcept>
-#include <iostream>
 #include <sstream>
 #include <time.h>
 #include <stdlib.h>
@@ -31,25 +31,33 @@
 #include <sys/types.h>
 #include <dirent.h>
 #include <unistd.h>
-#ifndef WIN32
-#include <libgen.h>
-#endif
+#include <assert.h>
+#include <physfs.h>
 #include <SDL.h>
-#include <SDL_mixer.h>
 #include <SDL_image.h>
-
-#include "gameconfig.h"
-#include "resources.h"
-#include "app/globals.h"
-#include "app/setup.h"
-#include "app/gettext.h"
-#include "audio/sound_manager.h"
-#include "control/joystickkeyboardcontroller.h"
-#include "misc.h"
-#include "game_session.h"
+#include <GL/gl.h>
+
+#include "gameconfig.hpp"
+#include "resources.hpp"
+#include "gettext.hpp"
+#include "audio/sound_manager.hpp"
+#include "video/surface.hpp"
+#include "video/texture_manager.hpp"
+#include "control/joystickkeyboardcontroller.hpp"
+#include "options_menu.hpp"
+#include "mainloop.hpp"
+#include "title.hpp"
+#include "game_session.hpp"
+#include "script_manager.hpp"
+#include "scripting/sound.hpp"
+#include "scripting/level.hpp"
+#include "scripting/wrapper_util.hpp"
+#include "file_system.hpp"
+#include "physfs/physfs_sdl.hpp"
 
 SDL_Surface* screen = 0;
 JoystickKeyboardController* main_controller = 0;
+TinyGetText::DictionaryManager dictionary_manager;
 
 static void init_config()
 {
@@ -57,97 +65,155 @@ static void init_config()
   try {
     config->load();
   } catch(std::exception& e) {
-#ifdef DEBUG
-    std::cerr << "Couldn't load config file: " << e.what() << "\n";
-#endif
+    log_info << "Couldn't load config file: " << e.what() << ", using default settings" << std::endl;
   }
 }
 
-static void find_directories()
+static void init_tinygettext()
 {
-  const char* home = getenv("HOME");
-  if(home == 0) {
-#ifdef DEBUG
-    std::cerr << "Couldn't find home directory.\n";
-#endif
-    home = ".";
-  }
-
-  user_dir = home;
-  user_dir += "/.supertux";
+  dictionary_manager.add_directory("locale");
+  dictionary_manager.set_charset("UTF-8");
+}
 
-  // Remove .supertux config file from old versions
-  if(FileSystem::faccessible(user_dir)) {
-    std::cerr << "Removing old config file " << user_dir << "\n";
-    remove(user_dir.c_str());
+static void init_physfs(const char* argv0)
+{
+  if(!PHYSFS_init(argv0)) {
+    std::stringstream msg;
+    msg << "Couldn't initialize physfs: " << PHYSFS_getLastError();
+    throw std::runtime_error(msg.str());
   }
 
-  // create directories
-  std::string savedir = user_dir + "/save";
-  mkdir(user_dir.c_str(), 0755);
-  mkdir(savedir.c_str(), 0755);
-
-  // try current directory as datadir
-  if(datadir.empty()) {
-    if(FileSystem::faccessible("./data/credits.txt")) {
-      datadir = "./data/";
+  // Initialize physfs (this is a slightly modified version of
+  // PHYSFS_setSaneConfig
+  const char* application = PACKAGE_NAME;
+  const char* userdir = PHYSFS_getUserDir();
+  const char* dirsep = PHYSFS_getDirSeparator();
+  char* writedir = new char[strlen(userdir) + strlen(application) + 2];
+
+  // Set configuration directory
+  sprintf(writedir, "%s.%s", userdir, application);
+  if(!PHYSFS_setWriteDir(writedir)) {
+    // try to create the directory
+    char* mkdir = new char[strlen(application) + 2];
+    sprintf(mkdir, ".%s", application);
+    if(!PHYSFS_setWriteDir(userdir) || !PHYSFS_mkdir(mkdir)) {
+      std::ostringstream msg;
+      msg << "Failed creating configuration directory '" 
+          << writedir << "': " << PHYSFS_getLastError();
+      delete[] writedir;
+      delete[] mkdir;
+      throw std::runtime_error(msg.str());
+    }
+    delete[] mkdir;
+    
+    if(!PHYSFS_setWriteDir(writedir)) {
+      std::ostringstream msg;
+      msg << "Failed to use configuration directory '" 
+          <<  writedir << "': " << PHYSFS_getLastError();
+      delete[] writedir;
+      throw std::runtime_error(msg.str());
     }
   }
-
-  // Detect datadir with some linux magic
-#ifndef WIN32
-  if(datadir.empty()) {
-    char exe_file[PATH_MAX];
-    if(readlink("/proc/self/exe", exe_file, PATH_MAX) < 0) {
-#ifdef DEBUG
-      std::cerr << "Couldn't read /proc/self/exe \n";
-#endif
-    } else {
-      std::string exedir = std::string(dirname(exe_file)) + "/";
-      std::string testdir = exedir + "./data/";
-      if(access(testdir.c_str(), F_OK) == 0) {
-        datadir = testdir;
-      }
-      
-      testdir = exedir + "../share/supertux/";
-      if(datadir.empty() && access(testdir.c_str(), F_OK) == 0) {
-        datadir = testdir;
+  PHYSFS_addToSearchPath(writedir, 0);
+  delete[] writedir;
+
+  // Search for archives and add them to the search path
+  const char* archiveExt = "zip";
+  char** rc = PHYSFS_enumerateFiles("/");
+  size_t extlen = strlen(archiveExt);
+
+  for(char** i = rc; *i != 0; ++i) {
+    size_t l = strlen(*i);
+    if((l > extlen) && ((*i)[l - extlen - 1] == '.')) {
+      const char* ext = (*i) + (l - extlen);
+      if(strcasecmp(ext, archiveExt) == 0) {
+        const char* d = PHYSFS_getRealDir(*i);
+        char* str = new char[strlen(d) + strlen(dirsep) + l + 1];
+        sprintf(str, "%s%s%s", d, dirsep, *i);
+        PHYSFS_addToSearchPath(str, 1);
+        delete[] str;
       }
-    }  
+    }
   }
-#endif
   
-#ifdef DATA_PREFIX
-  // use default location
-  if(datadir.empty()) {
-    datadir = DATA_PREFIX;
+  PHYSFS_freeList(rc);
+
+  // when started from source dir...
+  std::string dir = PHYSFS_getBaseDir();
+  dir += "/data";
+  std::string testfname = dir;
+  testfname += "/credits.txt";
+  bool sourcedir = false;
+  FILE* f = fopen(testfname.c_str(), "r");
+  if(f) {
+    fclose(f);
+    if(!PHYSFS_addToSearchPath(dir.c_str(), 1)) {
+      log_warning << "Couldn't add '" << dir << "' to physfs searchpath: " << PHYSFS_getLastError() << std::endl;
+    } else {
+      sourcedir = true;
+    }
+  }
+
+#ifdef MACOSX
+  // when started from Application file on Mac OS X...
+  dir = PHYSFS_getBaseDir();
+  dir += "SuperTux.app/Contents/Resources/data";
+  testfname = dir + "/credits.txt";
+  sourcedir = false;
+  f = fopen(testfname.c_str(), "r");
+  if(f) {
+    fclose(f);
+    if(!PHYSFS_addToSearchPath(dir.c_str(), 1)) {
+      msg_warning << "Couldn't add '" << dir << "' to physfs searchpath: " << PHYSFS_getLastError() << std::endl;
+    } else {
+      sourcedir = true;
+    }
   }
 #endif
 
-  if(datadir.empty())
-    throw std::runtime_error("Couldn't find datadir");
-}
+  if(!sourcedir) {
+#if defined(APPDATADIR) || defined(ENABLE_BINRELOC)
+    std::string datadir;
+#ifdef ENABLE_BINRELOC
+    char* brdatadir = br_strcat(DATADIR, "/" PACKAGE_NAME);
+    datadir = brdatadir;
+    free(brdatadir);
+#else
+    datadir = APPDATADIR;
+#endif
+    if(!PHYSFS_addToSearchPath(datadir.c_str(), 1)) {
+      log_warning << "Couldn't add '" << datadir << "' to physfs searchpath: " << PHYSFS_getLastError() << std::endl;
+    }
+#endif
+  }
 
-static void init_tinygettext()
-{
-  dictionary_manager.add_directory(datadir + "/locale");
-  dictionary_manager.set_charset("iso8859-1");
+  // allow symbolic links
+  PHYSFS_permitSymbolicLinks(1);
+
+  //show search Path
+  for(char** i = PHYSFS_getSearchPath(); *i != NULL; i++)
+    log_info << "[" << *i << "] is in the search path" << std::endl;
 }
 
 static void print_usage(const char* argv0)
 {
-  fprintf(stderr, _("Usage: %s [OPTIONS] LEVELFILE\n\n"), argv0);
+  fprintf(stderr, _("Usage: %s [OPTIONS] [LEVELFILE]\n\n"), argv0);
   fprintf(stderr,
           _("Options:\n"
-            "  -f, --fullscreen             Run in fullscreen mode.\n"
-            "  -w, --window                 Run in window mode.\n"
-            "  -g, --geometry WIDTHxHEIGHT  Run SuperTux in give resolution\n"
+            "  -f, --fullscreen             Run in fullscreen mode\n"
+            "  -w, --window                 Run in window mode\n"
+            "  -g, --geometry WIDTHxHEIGHT  Run SuperTux in given resolution\n"
+            "  --disable-sfx                Disable sound effects\n"
+            "  --disable-music              Disable music\n"
             "  --help                       Show this help message\n"
             "  --version                    Display SuperTux version and quit\n"
+            "  --show-fps                   Display framerate in levels\n"
+            "  --record-demo FILE LEVEL     Record a demo to FILE\n"
+            "  --play-demo FILE LEVEL       Play a recorded demo\n"
             "\n"));
 }
 
-static void parse_commandline(int argc, char** argv)
+static bool parse_commandline(int argc, char** argv)
 {
   for(int i = 1; i < argc; ++i) {
     std::string arg = argv[i];
@@ -168,21 +234,36 @@ static void parse_commandline(int argc, char** argv)
       }
     } else if(arg == "--show-fps") {
       config->show_fps = true;
+    } else if(arg == "--disable-sfx") {
+      config->sound_enabled = false;
+    } else if(arg == "--disable-music") {
+      config->music_enabled = false;
+    } else if(arg == "--play-demo") {
+      if(i+1 >= argc) {
+        print_usage(argv[0]);
+        throw std::runtime_error("Need to specify a demo filename");
+      }
+      config->start_demo = argv[++i];
+    } else if(arg == "--record-demo") {
+      if(i+1 >= argc) {
+        print_usage(argv[0]);
+        throw std::runtime_error("Need to specify a demo filename");
+      }
+      config->record_demo = argv[++i];
     } else if(arg == "--help") {
       print_usage(argv[0]);
-      throw std::runtime_error("");
+      return true;
     } else if(arg == "--version") {
-      std::cerr << PACKAGE_NAME << " " << PACKAGE_VERSION << "\n";
-      throw std::runtime_error("");
+      log_info << PACKAGE_NAME << " " << PACKAGE_VERSION << std::endl;
+      return true;
     } else if(arg[0] != '-') {
       config->start_level = arg;
     } else {
-      std::cerr << "Unknown option '" << arg << "'.\n";
-      std::cerr << "Use --help to see a list of options.\n";
+      log_warning << "Unknown option '" << arg << "'. Use --help to see a list of options" << std::endl;
     }
   }
 
-  // TODO joystick switchyes...
+  return false;
 }
 
 static void init_sdl()
@@ -192,8 +273,17 @@ static void init_sdl()
     msg << "Couldn't initialize SDL: " << SDL_GetError();
     throw std::runtime_error(msg.str());
   }
+  // just to be sure
+  atexit(SDL_Quit);
 
   SDL_EnableUNICODE(1);
+
+  // wait 100ms and clear SDL event queue because sometimes we have random
+  // joystick events in the queue on startup...
+  SDL_Delay(100);
+  SDL_Event dummy;
+  while(SDL_PollEvent(&dummy))
+      ;
 }
 
 static void check_gl_error()
@@ -221,9 +311,11 @@ static void check_gl_error()
       case GL_OUT_OF_MEMORY:
         errormsg = "out of memory";
         break;
+#ifdef GL_TABLE_TOO_LARGE
       case GL_TABLE_TOO_LARGE:
         errormsg = "table too large";
         break;
+#endif
       default:
         errormsg = "unknown error number";
         break;
@@ -236,6 +328,9 @@ static void check_gl_error()
 
 void init_video()
 {
+  if(texture_manager != NULL)
+    texture_manager->save_textures();
+  
   SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); 
   SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
   SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
@@ -259,21 +354,24 @@ void init_video()
   SDL_WM_SetCaption(PACKAGE_NAME " " PACKAGE_VERSION, 0);
 
   // set icon
-  SDL_Surface* icon = IMG_Load(
-    get_resource_filename("images/supertux.xpm").c_str());
+  SDL_Surface* icon = IMG_Load_RW(
+      get_physfs_SDLRWops("images/engine/icons/supertux.xpm"), true);
   if(icon != 0) {
     SDL_WM_SetIcon(icon, 0);
     SDL_FreeSurface(icon);
   }
 #ifdef DEBUG
   else {
-    std::cerr << "Warning: Couldn't find icon 'images/supertux.xpm'.\n";
+    log_warning << "Couldn't find icon 'images/engine/icons/supertux.xpm'" << std::endl;
   }
 #endif
 
   // setup opengl state and transform
   glDisable(GL_DEPTH_TEST);
   glDisable(GL_CULL_FACE);
+  glEnable(GL_TEXTURE_2D);
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
   glViewport(0, 0, screen->w, screen->h);
   glMatrixMode(GL_PROJECTION);
@@ -286,91 +384,176 @@ void init_video()
 
   check_gl_error();
 
-  Surface::reload_all();
+  if(texture_manager != NULL)
+    texture_manager->reload_textures();
+  else
+    texture_manager = new TextureManager();
 }
 
 static void init_audio()
 {
   sound_manager = new SoundManager();
   
-  int format = MIX_DEFAULT_FORMAT;
-  if(Mix_OpenAudio(config->audio_frequency, format, config->audio_channels,
-                   config->audio_chunksize) < 0) {
-    std::cerr << "Couldn't initialize audio ("
-              << config->audio_frequency << "HZ, " << config->audio_channels
-              << " Channels, Format " << format << ", ChunkSize "
-              << config->audio_chunksize << "): " << SDL_GetError() << "\n";
-    return;
-  }
-  sound_manager->set_audio_device_available(true);
   sound_manager->enable_sound(config->sound_enabled);
   sound_manager->enable_music(config->music_enabled);
-  
-  if(Mix_AllocateChannels(config->audio_voices) < 0) {
-    std::cerr << "Couldn't allocate '" << config->audio_voices << "' audio voices: "
-              << SDL_GetError() << "\n";
-    return;
-  }
 }
 
-static void quit_audio()
+static void init_scripting()
 {
-  if(sound_manager) {
-    if(sound_manager->audio_device_available())
-      Mix_CloseAudio();
+  ScriptManager::instance = new ScriptManager();
+
+  HSQUIRRELVM vm = ScriptManager::instance->get_vm();
+  sq_pushroottable(vm); 
+  expose_object(vm, -1, new Scripting::Sound(), "Sound", true);
+  expose_object(vm, -1, new Scripting::Level(), "Level", true);
+  sq_pop(vm, 1);
+}
 
+static void quit_audio()
+{
+  if(sound_manager != NULL) {
     delete sound_manager;
-    sound_manager = 0;
+    sound_manager = NULL;
+  }
+}
+
+void wait_for_event(float min_delay, float max_delay)
+{
+  assert(min_delay <= max_delay);
+  
+  Uint32 min = (Uint32) (min_delay * 1000);
+  Uint32 max = (Uint32) (max_delay * 1000);
+
+  Uint32 ticks = SDL_GetTicks();
+  while(SDL_GetTicks() - ticks < min) {
+    SDL_Delay(10);
+    sound_manager->update();
+  }
+
+  // clear event queue
+  SDL_Event event;
+  while (SDL_PollEvent(&event))
+  {}
+
+  /* Handle events: */
+  bool running = false;
+  ticks = SDL_GetTicks();
+  while(running) {
+    while(SDL_PollEvent(&event)) {
+      switch(event.type) {
+        case SDL_QUIT:
+          main_loop->quit();
+          break;
+        case SDL_KEYDOWN:
+        case SDL_JOYBUTTONDOWN:
+        case SDL_MOUSEBUTTONDOWN:
+          running = false;
+      }
+    }
+    if(SDL_GetTicks() - ticks >= (max - min))
+      running = false;
+    sound_manager->update();
+    SDL_Delay(10);
   }
 }
 
+#ifdef DEBUG
+static Uint32 last_timelog_ticks = 0;
+static const char* last_timelog_component = 0;
+
+static inline void timelog(const char* component)
+{
+  Uint32 current_ticks = SDL_GetTicks();
+  
+  if(last_timelog_component != 0) {
+    log_info << "Component '" << last_timelog_component <<  "' finished after " << (current_ticks - last_timelog_ticks) / 1000.0 << " seconds" << std::endl;
+  }
+
+  last_timelog_ticks = current_ticks;
+  last_timelog_component = component;
+}
+#else
+static inline void timelog(const char* )
+{
+}
+#endif
+
 int main(int argc, char** argv) 
 {
-#ifndef DEBUG // we want backtraces in debug mode so don't catch exceptions
+  int result = 0;
+    
   try {
-#endif
     srand(time(0));
+    init_physfs(argv[0]);
     init_sdl();
+    timelog("controller");
     main_controller = new JoystickKeyboardController();    
-    find_directories();
+    timelog("config");
     init_config();
+    timelog("tinygettext");
     init_tinygettext();
-    parse_commandline(argc, argv);
+    timelog("commandline");
+    if(parse_commandline(argc, argv))
+      return 0;
+    timelog("audio");
     init_audio();
+    timelog("video");
     init_video();
+    Console::instance = new Console(); 
+    timelog("scripting");
+    init_scripting();
 
-    setup_menu();
-    load_shared();
+    timelog("resources");
+    load_shared(); 
+    timelog(0);
+
+    main_loop = new MainLoop(); 
     if(config->start_level != "") {
-      GameSession session(config->start_level, ST_GL_LOAD_LEVEL_FILE);
-      session.run();
+      // we have a normal path specified at commandline not physfs paths.
+      // So we simply mount that path here...
+      std::string dir = FileSystem::dirname(config->start_level);
+      PHYSFS_addToSearchPath(dir.c_str(), true);
+      std::auto_ptr<GameSession> session
+        (new GameSession(FileSystem::basename(config->start_level)));
+      if(config->start_demo != "")
+        session->play_demo(config->start_demo);
+      if(config->record_demo != "")
+        session->record_demo(config->record_demo);
+      main_loop->push_screen(session.release());
     } else {
-      // normal game
-      title();
-    }    
-    
-#ifndef DEBUG
+      main_loop->push_screen(new TitleScreen());
+    }
+
+    main_loop->run();
   } catch(std::exception& e) {
-    std::cerr << "Unexpected exception: " << e.what() << std::endl;
-    return 1;
+    log_fatal << "Unexpected exception: " << e.what() << std::endl;
+    result = 1;
   } catch(...) {
-    std::cerr << "Unexpected exception." << std::endl;
-    return 1;
+    log_fatal << "Unexpected exception" << std::endl;
+    result = 1;
   }
-#endif
 
-  free_menu();
+  delete main_loop;
+  main_loop = NULL;
+
+  free_options_menu();
   unload_shared();
-#ifdef DEBUG
-  Surface::debug_check();
-#endif
   quit_audio();
 
   if(config)
     config->save();
   delete config;
+  config = NULL;
   delete main_controller;
+  main_controller = NULL;
+  delete Console::instance;
+  Console::instance = NULL;
+  delete ScriptManager::instance;
+  ScriptManager::instance = NULL; 
+  delete texture_manager;
+  texture_manager = NULL;
   SDL_Quit();
+  PHYSFS_deinit();
   
-  return 0;
+  return result;
 }