X-Git-Url: https://git.octo.it/?a=blobdiff_plain;ds=sidebyside;f=src%2Fsector.cpp;h=93a08585da46c1bbee0221cec75c3dcf94e22780;hb=53b4479f1e7e148ee0f8940de236359513bb4558;hp=51b8683d4a08a0cc2d61476dad93c6e5c292b8e6;hpb=6afe39823a25f6bf06f715205c1f51ddbe6cefae;p=supertux.git

diff --git a/src/sector.cpp b/src/sector.cpp
index 51b8683d4..93a08585d 100644
--- a/src/sector.cpp
+++ b/src/sector.cpp
@@ -1,7 +1,7 @@
 //  $Id$
 //
 //  SuperTux -  A Jump'n Run
-//  Copyright (C) 2004 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
@@ -25,12 +25,14 @@
 #include <fstream>
 #include <sstream>
 #include <stdexcept>
+#include <float.h>
 
 #include "sector.hpp"
 #include "player_status.hpp"
 #include "object/gameobjs.hpp"
 #include "object/camera.hpp"
 #include "object/background.hpp"
+#include "object/gradient.hpp"
 #include "object/particlesystem.hpp"
 #include "object/particlesystem_interactive.hpp"
 #include "object/tilemap.hpp"
@@ -56,51 +58,66 @@
 #include "object/bullet.hpp"
 #include "object/text_object.hpp"
 #include "badguy/jumpy.hpp"
-#include "badguy/spike.hpp"
 #include "trigger/sequence_trigger.hpp"
 #include "player_status.hpp"
-#include "scripting/script_interpreter.hpp"
-#include "scripting/sound.hpp"
-#include "scripting/scripted_object.hpp"
-#include "scripting/text.hpp"
-
-//#define USE_GRID
+#include "script_manager.hpp"
+#include "scripting/wrapper_util.hpp"
+#include "script_interface.hpp"
+#include "log.hpp"
 
 Sector* Sector::_current = 0;
 
+bool Sector::show_collrects = false;
+bool Sector::draw_solids_only = false;
+
 Sector::Sector()
-  : gravity(10), player(0), solids(0), camera(0),
-    currentmusic(LEVEL_MUSIC)
+  : currentmusic(LEVEL_MUSIC), gravity(10),
+    player(0), solids(0), camera(0)
 {
-  song_title = "chipdisko.ogg";
-  player = new Player(&player_status);
-  add_object(player);
+  add_object(new Player(player_status));
+  add_object(new DisplayEffect());
+  add_object(new TextObject());
 
 #ifdef USE_GRID
-  grid = new CollisionGrid(32000, 32000);
-#else
-  grid = 0;
+  grid.reset(new CollisionGrid(32000, 32000));
 #endif
+
+  script_manager.reset(new ScriptManager(ScriptManager::instance));
+
+  // create a new squirrel table for the sector
+  HSQUIRRELVM vm = ScriptManager::instance->get_vm();
+  
+  sq_newtable(vm);
+  sq_pushroottable(vm);
+  if(SQ_FAILED(sq_setdelegate(vm, -2)))
+    throw Scripting::SquirrelError(vm, "Couldn't set sector_table delegate");
+
+  sq_resetobject(&sector_table);
+  if(SQ_FAILED(sq_getstackobj(vm, -1, &sector_table)))
+    throw Scripting::SquirrelError(vm, "Couldn't get sector table");
+  sq_addref(vm, &sector_table);
+  sq_pop(vm, 1);
 }
 
 Sector::~Sector()
 {
+  deactivate();
+  
+  script_manager.reset(NULL);
+  sq_release(ScriptManager::instance->get_vm(), &sector_table);
+ 
   update_game_objects();
   assert(gameobjects_new.size() == 0);
 
-  delete grid;
-
   for(GameObjects::iterator i = gameobjects.begin(); i != gameobjects.end();
       ++i) {
+    before_object_remove(*i);
     delete *i;
   }
 
   for(SpawnPoints::iterator i = spawnpoints.begin(); i != spawnpoints.end();
       ++i)
     delete *i;
-    
-  if(_current == this)
-    _current = 0;
 }
 
 GameObject*
@@ -137,7 +154,7 @@ Sector::parse_object(const std::string& name, const lisp::Lisp& reader)
   try {
     return create_object(name, reader);
   } catch(std::exception& e) {
-    std::cerr << e.what() << "\n";
+    log_warning << e.what() << "" << std::endl;
   }
   
   return 0;
@@ -145,9 +162,7 @@ Sector::parse_object(const std::string& name, const lisp::Lisp& reader)
 
 void
 Sector::parse(const lisp::Lisp& sector)
-{
-  _current = this;
-  
+{  
   lisp::ListIterator iter(&sector);
   while(iter.next()) {
     const std::string& token = iter.item();
@@ -156,7 +171,7 @@ Sector::parse(const lisp::Lisp& sector)
     } else if(token == "gravity") {
       iter.value()->get(gravity);
     } else if(token == "music") {
-      iter.value()->get(song_title);
+      iter.value()->get(music);
     } else if(token == "spawnpoint") {
       SpawnPoint* sp = new SpawnPoint(iter.lisp());
       spawnpoints.push_back(sp);
@@ -171,14 +186,16 @@ Sector::parse(const lisp::Lisp& sector)
   }
 
   update_game_objects();
+
+  if(!solids)
+    throw std::runtime_error("sector does not contain a solid tile layer.");
+
   fix_old_tiles();
   if(!camera) {
-    std::cerr << "sector '" << name << "' does not contain a camera.\n";
+    log_warning << "sector '" << name << "' does not contain a camera." << std::endl;
     update_game_objects();
     add_object(new Camera(this));
   }
-  if(!solids)
-    throw std::runtime_error("sector does not contain a solid tile layer.");
 
   update_game_objects();
 }
@@ -186,8 +203,6 @@ Sector::parse(const lisp::Lisp& sector)
 void
 Sector::parse_old_format(const lisp::Lisp& reader)
 {
-  _current = this;
-  
   name = "main";
   reader.get("gravity", gravity);
 
@@ -202,25 +217,26 @@ Sector::parse_old_format(const lisp::Lisp& reader)
   reader.get("bkgd_red_top", r);
   reader.get("bkgd_green_top",  g);
   reader.get("bkgd_blue_top",  b);
-  bkgd_top.red = r;
-  bkgd_top.green = g;
-  bkgd_top.blue = b;
+  bkgd_top.red = static_cast<float> (r) / 255.0f;
+  bkgd_top.green = static_cast<float> (g) / 255.0f;
+  bkgd_top.blue = static_cast<float> (b) / 255.0f;
   
   reader.get("bkgd_red_bottom",  r);
   reader.get("bkgd_green_bottom", g);
   reader.get("bkgd_blue_bottom", b);
-  bkgd_bottom.red = r;
-  bkgd_bottom.green = g;
-  bkgd_bottom.blue = b;
+  bkgd_bottom.red = static_cast<float> (r) / 255.0f;
+  bkgd_bottom.green = static_cast<float> (g) / 255.0f;
+  bkgd_bottom.blue = static_cast<float> (b) / 255.0f;
   
   if(backgroundimage != "") {
-    Background* background = new Background;
-    background->set_image(backgroundimage, bgspeed);
+    Background* background = new Background();
+    background->set_image(
+            std::string("images/background/") + backgroundimage, bgspeed);
     add_object(background);
   } else {
-    Background* background = new Background;
-    background->set_gradient(bkgd_top, bkgd_bottom);
-    add_object(background);
+    Gradient* gradient = new Gradient();
+    gradient->set_gradient(bkgd_top, bkgd_bottom);
+    add_object(gradient);
   }
 
   std::string particlesystem;
@@ -241,10 +257,11 @@ Sector::parse_old_format(const lisp::Lisp& reader)
   spawn->name = "main";
   spawnpoints.push_back(spawn);
 
-  song_title = "chipdisko.ogg";
-  reader.get("music", song_title);
+  music = "chipdisko.ogg";
+  reader.get("music", music);
+  music = "music/" + music;
 
-  int width, height = 15;
+  int width = 30, height = 15;
   reader.get("width", width);
   reader.get("height", height);
   
@@ -283,7 +300,7 @@ Sector::parse_old_format(const lisp::Lisp& reader)
           spawnpoints.push_back(sp);
           }
       } else {
-        std::cerr << "Unknown token '" << iter.item() << "' in reset-points.\n";
+        log_warning << "Unknown token '" << iter.item() << "' in reset-points." << std::endl;
       }
     }
   }
@@ -297,7 +314,7 @@ Sector::parse_old_format(const lisp::Lisp& reader)
       if(object) {
         add_object(object);
       } else {
-        std::cerr << "Unknown object '" << iter.item() << "' in level.\n";
+        log_warning << "Unknown object '" << iter.item() << "' in level." << std::endl;
       }
     }
   }
@@ -307,10 +324,12 @@ Sector::parse_old_format(const lisp::Lisp& reader)
   add_object(camera);
 
   update_game_objects();
+
+  if(solids == 0)
+    throw std::runtime_error("sector does not contain a solid tile layer.");
+
   fix_old_tiles();
   update_game_objects();
-  if(solids == 0)
-    throw std::runtime_error("sector does not contain a solid tile layer.");  
 }
 
 void
@@ -325,18 +344,6 @@ Sector::fix_old_tiles()
       if(tile->getID() == 112) {
         add_object(new InvisibleBlock(pos));
         solids->change(x, y, 0);
-      } else if(tile->getID() == 295) {
-        add_object(new Spike(pos, Spike::NORTH));
-        solids->change(x, y, 0);
-      } else if(tile->getID() == 296) {
-        add_object(new Spike(pos, Spike::EAST));
-        solids->change(x, y, 0);
-      } else if(tile->getID() == 297) {
-        add_object(new Spike(pos, Spike::SOUTH));
-        solids->change(x, y, 0);
-      } else if(tile->getID() == 298) {
-        add_object(new Spike(pos, Spike::WEST));
-        solids->change(x, y, 0);
       } else if(tile->getAttributes() & Tile::COIN) {
         add_object(new Coin(pos));
         solids->change(x, y, 0);
@@ -351,7 +358,7 @@ Sector::fix_old_tiles()
         add_object(new SequenceTrigger(pos, sequence));
         solids->change(x, y, 0);
       }
-    }                                                   
+    }
   }
 }
 
@@ -360,7 +367,7 @@ Sector::write(lisp::Writer& writer)
 {
   writer.write_string("name", name);
   writer.write_float("gravity", gravity);
-  writer.write_string("music", song_title);
+  writer.write_string("music", music);
 
   // write spawnpoints
   for(SpawnPoints::iterator i = spawnpoints.begin(); i != spawnpoints.end();
@@ -382,6 +389,21 @@ Sector::write(lisp::Writer& writer)
   }
 }
 
+HSQUIRRELVM
+Sector::run_script(std::istream& in, const std::string& sourcename)
+{
+  // create new thread and keep a weakref
+  HSQUIRRELVM vm = script_manager->create_thread();
+
+  // set sector_table as roottable for the thread
+  sq_pushobject(vm, sector_table);
+  sq_setroottable(vm);
+
+  Scripting::compile_and_run(vm, in, sourcename);
+
+  return vm;
+}
+
 void
 Sector::add_object(GameObject* object)
 {
@@ -416,7 +438,7 @@ Sector::activate(const std::string& spawnpoint)
     }
   }                                                                           
   if(!sp) {
-    std::cerr << "Spawnpoint '" << spawnpoint << "' not found.\n";
+    log_warning << "Spawnpoint '" << spawnpoint << "' not found." << std::endl;
     if(spawnpoint != "main") {
       activate("main");
     } else {
@@ -425,21 +447,66 @@ Sector::activate(const std::string& spawnpoint)
   } else {
     activate(sp->pos);
   }
+}
+
+void
+Sector::activate(const Vector& player_pos)
+{
+  if(_current != this) {
+    if(_current != NULL)
+      _current->deactivate();
+    _current = this;
+
+    // register sectortable as current_sector in scripting
+    HSQUIRRELVM vm = ScriptManager::instance->get_vm();
+    sq_pushroottable(vm);
+    sq_pushstring(vm, "sector", -1);
+    sq_pushobject(vm, sector_table);
+    if(SQ_FAILED(sq_createslot(vm, -3)))
+      throw Scripting::SquirrelError(vm, "Couldn't set sector in roottable");
+    sq_pop(vm, 1);
+
+    for(GameObjects::iterator i = gameobjects.begin();
+        i != gameobjects.end(); ++i) {
+      GameObject* object = *i;
+
+      try_expose(object);
+    }
+  }
+
+  player->move(player_pos);
+  camera->reset(player->get_pos());
+  update_game_objects();
 
   // Run init script
   if(init_script != "") {
-    ScriptInterpreter::add_script_object(this,
-        std::string("Sector(") + name + ") - init", init_script);
+    std::istringstream in(init_script);
+    run_script(in, std::string("Sector(") + name + ") - init");
   }
 }
 
 void
-Sector::activate(const Vector& player_pos)
+Sector::deactivate()
 {
-  _current = this;
+  if(_current != this)
+    return;
 
-  player->move(player_pos);
-  camera->reset(player->get_pos());
+  // remove sector entry from global vm
+  HSQUIRRELVM vm = ScriptManager::instance->get_vm();
+  sq_pushroottable(vm);
+  sq_pushstring(vm, "sector", -1);
+  if(SQ_FAILED(sq_deleteslot(vm, -2, SQFalse)))
+    throw Scripting::SquirrelError(vm, "Couldn't unset sector in roottable");
+  sq_pop(vm, 1);
+  
+  for(GameObjects::iterator i = gameobjects.begin();
+      i != gameobjects.end(); ++i) {
+    GameObject* object = *i;
+    
+    try_unexpose(object);
+  }
+
+  _current = NULL;
 }
 
 Rect
@@ -453,6 +520,8 @@ Sector::get_active_region()
 void
 Sector::update(float elapsed_time)
 {
+  script_manager->update();
+
   player->check_bounds(camera);
 
 #if 0
@@ -476,7 +545,7 @@ Sector::update(float elapsed_time)
 #endif
   
   /* Handle all possible collisions. */
-  collision_handler();                                                                              
+  handle_collisions();
   update_game_objects();
 }
 
@@ -484,6 +553,30 @@ void
 Sector::update_game_objects()
 {
   /** cleanup marked objects */
+  for(std::vector<Bullet*>::iterator i = bullets.begin();
+      i != bullets.end(); /* nothing */) {
+    Bullet* bullet = *i;
+    if(bullet->is_valid()) {
+      ++i;
+      continue;
+    }
+
+    i = bullets.erase(i);
+  }
+  for(MovingObjects::iterator i = moving_objects.begin();
+      i != moving_objects.end(); /* nothing */) {
+    MovingObject* moving_object = *i;
+    if(moving_object->is_valid()) {
+      ++i;
+      continue;
+    }
+
+#ifdef USE_GRID
+    grid->remove_object(moving_object);
+#endif
+    
+    i = moving_objects.erase(i);
+  }
   for(std::vector<GameObject*>::iterator i = gameobjects.begin();
       i != gameobjects.end(); /* nothing */) {
     GameObject* object = *i;
@@ -492,19 +585,9 @@ Sector::update_game_objects()
       ++i;
       continue;
     }
+
+    before_object_remove(object);
     
-    Bullet* bullet = dynamic_cast<Bullet*> (object);
-    if(bullet) {
-      bullets.erase(
-          std::remove(bullets.begin(), bullets.end(), bullet),
-          bullets.end());
-    }
-#ifdef USE_GRID
-    MovingObject* movingobject = dynamic_cast<MovingObject*> (object);
-    if(movingobject) {
-      grid->remove_object(movingobject);
-    }
-#endif
     delete *i;
     i = gameobjects.erase(i);
   }
@@ -514,64 +597,131 @@ Sector::update_game_objects()
       i != gameobjects_new.end(); ++i)
   {
     GameObject* object = *i;
+
+    before_object_add(object);
     
-    Bullet* bullet = dynamic_cast<Bullet*> (object);
-    if(bullet)
-      bullets.push_back(bullet);
+    gameobjects.push_back(object);
+  }
+  gameobjects_new.clear();
+}
 
+bool
+Sector::before_object_add(GameObject* object)
+{
+  Bullet* bullet = dynamic_cast<Bullet*> (object);
+  if(bullet)
+    bullets.push_back(bullet);
+
+  MovingObject* movingobject = dynamic_cast<MovingObject*> (object);
+  if(movingobject) {
+    moving_objects.push_back(movingobject);
 #ifdef USE_GRID
-    MovingObject* movingobject = dynamic_cast<MovingObject*> (object);
-    if(movingobject)
-      grid->add_object(movingobject);
+    grid->add_object(movingobject);
 #endif
-    
-    TileMap* tilemap = dynamic_cast<TileMap*> (object);
-    if(tilemap && tilemap->is_solid()) {
-      if(solids == 0) {
-        solids = tilemap;
-      } else {
-        std::cerr << "Another solid tilemaps added. Ignoring.";
-      }
+  }
+  
+  TileMap* tilemap = dynamic_cast<TileMap*> (object);
+  if(tilemap && tilemap->is_solid()) {
+    if(solids == 0) {
+      solids = tilemap;
+    } else {
+      log_warning << "Another solid tilemaps added. Ignoring" << std::endl;
     }
+  }
 
-    Camera* camera = dynamic_cast<Camera*> (object);
-    if(camera) {
-      if(this->camera != 0) {
-        std::cerr << "Warning: Multiple cameras added. Ignoring.";
-        continue;
-      }
-      this->camera = camera;
+  Camera* camera = dynamic_cast<Camera*> (object);
+  if(camera) {
+    if(this->camera != 0) {
+      log_warning << "Multiple cameras added. Ignoring" << std::endl;
+      return false;
     }
+    this->camera = camera;
+  }
 
-    gameobjects.push_back(object);
+  Player* player = dynamic_cast<Player*> (object);
+  if(player) {
+    if(this->player != 0) {
+      log_warning << "Multiple players added. Ignoring" << std::endl;
+      return false;
+    }
+    this->player = player;
   }
-  gameobjects_new.clear();
+
+  if(_current == this) {
+    try_expose(object);
+  }
+  
+  return true;
+}
+
+void
+Sector::try_expose(GameObject* object)
+{
+  ScriptInterface* interface = dynamic_cast<ScriptInterface*> (object);
+  if(interface != NULL) {
+    HSQUIRRELVM vm = script_manager->get_vm();
+    sq_pushobject(vm, sector_table);
+    interface->expose(vm, -1);
+    sq_pop(vm, 1);
+  }
+}
+
+void
+Sector::before_object_remove(GameObject* object)
+{
+  if(_current == this)
+    try_unexpose(object);
 }
 
 void
+Sector::try_unexpose(GameObject* object)
+{
+  ScriptInterface* interface = dynamic_cast<ScriptInterface*> (object);
+  if(interface != NULL) {
+    HSQUIRRELVM vm = script_manager->get_vm();
+    int oldtop = sq_gettop(vm);
+    sq_pushobject(vm, sector_table);
+    try {
+      interface->unexpose(vm, -1);
+    } catch(std::exception& e) {
+      log_warning << "Couldn't unregister object: " << e.what() << std::endl;
+    }
+    sq_settop(vm, oldtop);
+  }
+} 
+
+void
 Sector::draw(DrawingContext& context)
 {
   context.push_transform();
   context.set_translation(camera->get_translation());
 
-#if 0
-  CollisionGridIterator iter(*grid, get_active_region());
-  while(MovingObject* object = iter.next()) {
-    if(!object->is_valid())
-      continue;
-
-    object->draw(context);
-  }
-#else
   for(GameObjects::iterator i = gameobjects.begin();
       i != gameobjects.end(); ++i) {
     GameObject* object = *i; 
     if(!object->is_valid())
       continue;
-    
+
+    if (draw_solids_only)
+    {
+      TileMap* tm = dynamic_cast<TileMap*>(object);
+      if (tm && !tm->is_solid())
+        continue;
+    }
+
     object->draw(context);
   }
-#endif
+
+  if(show_collrects) {
+    Color col(0.2, 0.2, 0.2, 0.7);
+    for(MovingObjects::iterator i = moving_objects.begin();
+            i != moving_objects.end(); ++i) {
+      MovingObject* object = *i;
+      const Rect& rect = object->get_bbox();
+
+      context.draw_filled_rect(rect, col, LAYER_FOREGROUND1 + 10);
+    }
+  }
 
   context.pop_transform();
 }
@@ -579,56 +729,34 @@ Sector::draw(DrawingContext& context)
 static const float DELTA = .001;
 
 void
-Sector::collision_tilemap(MovingObject* object, int depth)
+Sector::collision_tilemap(const Rect& dest, const Vector& movement,
+                          CollisionHit& hit) const
 {
-  if(depth >= 4) {
-#ifdef DEBUG
-    std::cout << "Max collision depth reached.\n";
-#endif
-    object->movement = Vector(0, 0);
-    return;
-  }
-
   // calculate rectangle where the object will move
-  float x1, x2;
-  if(object->get_movement().x >= 0) {
-    x1 = object->get_pos().x;
-    x2 = object->get_bbox().p2.x + object->get_movement().x;
-  } else {
-    x1 = object->get_pos().x + object->get_movement().x;
-    x2 = object->get_bbox().p2.x;
-  }
-  float y1, y2;
-  if(object->get_movement().y >= 0) {
-    y1 = object->get_pos().y;
-    y2 = object->get_bbox().p2.y + object->get_movement().y;
-  } else {
-    y1 = object->get_pos().y + object->get_movement().y;
-    y2 = object->get_bbox().p2.y;
-  }
+  float x1 = dest.get_left();
+  float x2 = dest.get_right();
+  float y1 = dest.get_top();
+  float y2 = dest.get_bottom();
 
   // test with all tiles in this rectangle
-  int starttilex = int(x1-1) / 32;
-  int starttiley = int(y1-1) / 32;
-  int max_x = int(x2+1);
-  int max_y = int(y2+1);
-
-  CollisionHit temphit, hit;
-  Rect dest = object->get_bbox();
-  dest.move(object->movement);
-  hit.time = -1; // represents an invalid value
+  int starttilex = int(x1) / 32;
+  int starttiley = int(y1) / 32;
+  int max_x = int(x2 + (1 - DELTA));
+  int max_y = int(y2 + (1 - DELTA));
+
+  CollisionHit temphit;
   for(int x = starttilex; x*32 < max_x; ++x) {
     for(int y = starttiley; y*32 < max_y; ++y) {
       const Tile* tile = solids->get_tile(x, y);
       if(!tile)
         continue;
       // skip non-solid tiles
-      if(!(tile->getAttributes() & Tile::SOLID))
+      if(tile->getAttributes() == 0)
         continue;
       // only handle unisolid when the player is falling down and when he was
       // above the tile before
       if(tile->getAttributes() & Tile::UNISOLID) {
-        if(object->movement.y < 0 || object->get_bbox().p2.y > y*32)
+        if(movement.y < 0 || dest.get_top() - movement.y > y*32)
           continue;
       }
 
@@ -638,114 +766,321 @@ Sector::collision_tilemap(MovingObject* object, int depth)
         Vector p2((x+1)*32, (y+1)*32);
         triangle = AATriangle(p1, p2, tile->getData());
 
-        if(Collision::rectangle_aatriangle(temphit, dest, object->movement,
+        if(Collision::rectangle_aatriangle(temphit, dest, movement,
               triangle)) {
-          if(temphit.time > hit.time)
+          if(temphit.time > hit.time && (tile->getAttributes() & Tile::SOLID)) {
             hit = temphit;
+          }
         }
       } else { // normal rectangular tile
         Rect rect(x*32, y*32, (x+1)*32, (y+1)*32);
-        if(Collision::rectangle_rectangle(temphit, dest,
-              object->movement, rect)) {
-          if(temphit.time > hit.time)
+        if(Collision::rectangle_rectangle(temphit, dest, movement, rect)) {
+          if(temphit.time > hit.time && (tile->getAttributes() & Tile::SOLID)) {
             hit = temphit;
+          }
         }
       }
     }
   }
+}
 
-  // did we collide at all?
-  if(hit.time < 0)
-    return;
+uint32_t
+Sector::collision_tile_attributes(const Rect& dest) const
+{
+  /** XXX This function doesn't work correctly as it will check all tiles
+   * in the bounding box of the object movement, this might include tiles
+   * that have actually never been touched by the object
+   * (though this only occures for very fast objects...)
+   */
  
-  // call collision function
-  HitResponse response = object->collision(*solids, hit);
-  if(response == ABORT_MOVE) {
-    object->movement = Vector(0, 0);
-    return;
+#if 0
+  // calculate rectangle where the object will move
+  float x1, x2;
+  if(object->get_movement().x >= 0) {
+    x1 = object->get_bbox().p1.x;
+    x2 = object->get_bbox().p2.x + object->get_movement().x;
+  } else {
+    x1 = object->get_bbox().p1.x + object->get_movement().x;
+    x2 = object->get_bbox().p2.x;
   }
-  if(response == FORCE_MOVE) {
-      return;
+  float y1, y2;
+  if(object->get_movement().y >= 0) {
+    y1 = object->get_bbox().p1.y;
+    y2 = object->get_bbox().p2.y + object->get_movement().y;
+  } else {
+    y1 = object->get_bbox().p1.y + object->get_movement().y;
+    y2 = object->get_bbox().p2.y;
   }
-  // move out of collision and try again
-  object->movement += hit.normal * (hit.depth + DELTA);
-  collision_tilemap(object, depth+1);
+#endif
+  float x1 = dest.p1.x;
+  float y1 = dest.p1.y;
+  float x2 = dest.p2.x;
+  float y2 = dest.p2.y;
+
+  // test with all tiles in this rectangle
+  int starttilex = int(x1) / 32;
+  int starttiley = int(y1) / 32;
+  int max_x = int(x2);
+  int max_y = int(y2);
+
+  uint32_t result = 0;
+  for(int x = starttilex; x*32 < max_x; ++x) {
+    for(int y = starttiley; y*32 < max_y; ++y) {
+      const Tile* tile = solids->get_tile(x, y);
+      if(!tile)
+        continue;
+      result |= tile->getAttributes();
+    }
+  }
+
+  return result;
 }
 
 void
-Sector::collision_object(MovingObject* object1, MovingObject* object2)
+Sector::collision_object(MovingObject* object1, MovingObject* object2) const
 {
   CollisionHit hit;
-  Rect dest1 = object1->get_bbox();
-  dest1.move(object1->get_movement());
-  Rect dest2 = object2->get_bbox();
-  dest2.move(object2->get_movement());
 
   Vector movement = object1->get_movement() - object2->get_movement();
-  if(Collision::rectangle_rectangle(hit, dest1, movement, dest2)) {
+  if(Collision::rectangle_rectangle(hit, object1->dest, movement, object2->dest)) {
     HitResponse response1 = object1->collision(*object2, hit);
     hit.normal *= -1;
     HitResponse response2 = object2->collision(*object1, hit);
 
     if(response1 != CONTINUE) {
       if(response1 == ABORT_MOVE)
-        object1->movement = Vector(0, 0);
+        object1->dest = object1->get_bbox();
       if(response2 == CONTINUE)
-        object2->movement += hit.normal * (hit.depth + DELTA);
+        object2->dest.move(hit.normal * (hit.depth + DELTA));
     } else if(response2 != CONTINUE) {
       if(response2 == ABORT_MOVE)
-        object2->movement = Vector(0, 0);
+        object2->dest = object2->get_bbox();
       if(response1 == CONTINUE)
-        object1->movement += -hit.normal * (hit.depth + DELTA);
+        object1->dest.move(-hit.normal * (hit.depth + DELTA));
     } else {
-      object1->movement += -hit.normal * (hit.depth/2 + DELTA);
-      object2->movement += hit.normal * (hit.depth/2 + DELTA);
+      object1->dest.move(-hit.normal * (hit.depth/2 + DELTA));
+      object2->dest.move(hit.normal * (hit.depth/2 + DELTA));
     }
   }
 }
 
-void
-Sector::collision_handler()
+bool
+Sector::collision_static(MovingObject* object, const Vector& movement)
 {
-#ifdef USE_GRID
-  grid->check_collisions();
-#else
-  for(std::vector<GameObject*>::iterator i = gameobjects.begin();
-      i != gameobjects.end(); ++i) {
-    GameObject* gameobject = *i;
-    if(!gameobject->is_valid())
+  GameObject* collided_with = solids;
+  CollisionHit hit;
+  hit.time = -1;
+
+  collision_tilemap(object->dest, movement, hit);
+
+  // collision with other (static) objects
+  CollisionHit temphit;
+  for(MovingObjects::iterator i2 = moving_objects.begin();
+      i2 != moving_objects.end(); ++i2) {
+    MovingObject* moving_object_2 = *i2;
+    if(moving_object_2->get_group() != COLGROUP_STATIC
+        || !moving_object_2->is_valid())
       continue;
-    MovingObject* movingobject = dynamic_cast<MovingObject*> (gameobject);
-    if(!movingobject)
+        
+    Rect dest = moving_object_2->dest;
+
+    Vector rel_movement 
+      = movement - moving_object_2->get_movement();
+
+    if(Collision::rectangle_rectangle(temphit, object->dest, rel_movement, dest)
+        && temphit.time > hit.time) {
+      hit = temphit;
+      collided_with = moving_object_2;
+    }
+  }
+
+  if(hit.time < 0)
+    return true;
+
+  HitResponse response = object->collision(*collided_with, hit);
+  hit.normal *= -1;
+  if(collided_with != solids) {
+    MovingObject* moving_object = (MovingObject*) collided_with;
+    HitResponse other_response = moving_object->collision(*object, hit);
+    if(other_response == ABORT_MOVE) {
+      moving_object->dest = moving_object->get_bbox();
+    } else if(other_response == FORCE_MOVE) {
+      // the static object "wins" move tux out of the collision
+      object->dest.move(-hit.normal * (hit.depth + DELTA));
+      return false;
+    } else if(other_response == PASS_MOVEMENT) {
+      object->dest.move(moving_object->get_movement());
+      //object->movement += moving_object->get_movement();
+    }
+  }
+
+  if(response == CONTINUE) {
+    object->dest.move(-hit.normal * (hit.depth + DELTA));
+    return false;
+  } else if(response == ABORT_MOVE) {
+    object->dest = object->get_bbox();
+    return true;
+  }
+  
+  // force move
+  return false;
+}
+
+void
+Sector::handle_collisions()
+{
+  // calculate destination positions of the objects
+  for(MovingObjects::iterator i = moving_objects.begin();
+      i != moving_objects.end(); ++i) {
+    MovingObject* moving_object = *i;
+
+    moving_object->dest = moving_object->get_bbox();
+    moving_object->dest.move(moving_object->get_movement());
+  }
+    
+  // part1: COLGROUP_MOVING vs COLGROUP_STATIC and tilemap
+  //   we do this up to 4 times and have to sort all results for the smallest
+  //   one before we can continue here
+  for(MovingObjects::iterator i = moving_objects.begin();
+      i != moving_objects.end(); ++i) {
+    MovingObject* moving_object = *i;
+    if((moving_object->get_group() != COLGROUP_MOVING
+          && moving_object->get_group() != COLGROUP_MOVING_ONLY_STATIC)
+        || !moving_object->is_valid())
       continue;
-    if(movingobject->get_flags() & GameObject::FLAG_NO_COLLDET) {
-      movingobject->bbox.move(movingobject->movement);
-      movingobject->movement = Vector(0, 0);
+
+    Vector movement = moving_object->get_movement();
+
+    // test if x or y movement is dominant
+    if(fabsf(moving_object->get_movement().x) < fabsf(moving_object->get_movement().y)) {
+
+      // test in x direction first, then y direction
+      moving_object->dest.move(Vector(0, -movement.y));
+      for(int i = 0; i < 2; ++i) {
+        bool res = collision_static(moving_object, Vector(movement.x, 0));
+        if(res)
+          break;
+      }
+      moving_object->dest.move(Vector(0, movement.y));
+      for(int i = 0; i < 2; ++i) {
+        bool res = collision_static(moving_object, Vector(0, movement.y));
+        if(res)
+          break;
+      }
+      
+    } else {
+
+      // test in y direction first, then x direction
+      moving_object->dest.move(Vector(-movement.x, 0));
+      for(int i = 0; i < 2; ++i) {
+        bool res = collision_static(moving_object, Vector(0, movement.y));
+        if(res)
+          break;
+      }
+      moving_object->dest.move(Vector(movement.x, 0)); 
+      for(int i = 0; i < 2; ++i) {
+        bool res = collision_static(moving_object, Vector(movement.x, 0));
+        if(res)
+          break;
+      }
+    }
+  }
+
+  // part2: COLGROUP_MOVING vs tile attributes
+  for(MovingObjects::iterator i = moving_objects.begin();
+      i != moving_objects.end(); ++i) {
+    MovingObject* moving_object = *i;
+    if((moving_object->get_group() != COLGROUP_MOVING
+          && moving_object->get_group() != COLGROUP_MOVING_ONLY_STATIC)
+        || !moving_object->is_valid())
       continue;
+
+    uint32_t tile_attributes = collision_tile_attributes(moving_object->dest);
+    if(tile_attributes > Tile::FIRST_INTERESTING_FLAG) {
+      moving_object->collision_tile(tile_attributes);
     }
+  }
 
-    // collision with tilemap
-    if(! (movingobject->movement == Vector(0, 0)))
-      collision_tilemap(movingobject, 0);
+  // part2.5: COLGROUP_MOVING vs COLGROUP_TOUCHABLE
+  for(MovingObjects::iterator i = moving_objects.begin();
+      i != moving_objects.end(); ++i) {
+    MovingObject* moving_object = *i;
+    if(moving_object->get_group() != COLGROUP_MOVING
+        || !moving_object->is_valid())
+      continue;
 
-    // collision with other objects
-    for(std::vector<GameObject*>::iterator i2 = i+1;
-        i2 != gameobjects.end(); ++i2) {
-      GameObject* other_object = *i2;
-      if(!other_object->is_valid() 
-          || other_object->get_flags() & GameObject::FLAG_NO_COLLDET)
+    for(MovingObjects::iterator i2 = moving_objects.begin();
+        i2 != moving_objects.end(); ++i2) {
+      MovingObject* moving_object_2 = *i2;
+      if(moving_object_2->get_group() != COLGROUP_TOUCHABLE
+         || !moving_object_2->is_valid())
         continue;
-      MovingObject* movingobject2 = dynamic_cast<MovingObject*> (other_object);
-      if(!movingobject2)
+
+      collision_object(moving_object, moving_object_2);
+    } 
+  }
+
+  // part3: COLGROUP_MOVING vs COLGROUP_MOVING
+  for(MovingObjects::iterator i = moving_objects.begin();
+      i != moving_objects.end(); ++i) {
+    MovingObject* moving_object = *i;
+
+    if(moving_object->get_group() != COLGROUP_MOVING
+        || !moving_object->is_valid())
+      continue;
+
+    for(MovingObjects::iterator i2 = i+1;
+        i2 != moving_objects.end(); ++i2) {
+      MovingObject* moving_object_2 = *i2;
+      if(moving_object_2->get_group() != COLGROUP_MOVING
+         || !moving_object_2->is_valid())
         continue;
 
-      collision_object(movingobject, movingobject2);
+      collision_object(moving_object, moving_object_2);
+    }    
+  }
+
+  // apply object movement
+  for(MovingObjects::iterator i = moving_objects.begin();
+      i != moving_objects.end(); ++i) {
+    MovingObject* moving_object = *i;
+
+    moving_object->bbox = moving_object->dest;
+    moving_object->movement = Vector(0, 0);
+  }
+}
+
+bool
+Sector::is_free_space(const Rect& rect) const
+{
+  // test with all tiles in this rectangle
+  int starttilex = int(rect.p1.x) / 32;
+  int starttiley = int(rect.p1.y) / 32;
+  int max_x = int(rect.p2.x);
+  int max_y = int(rect.p2.y);
+
+  for(int x = starttilex; x*32 < max_x; ++x) {
+    for(int y = starttiley; y*32 < max_y; ++y) {
+      const Tile* tile = solids->get_tile(x, y);
+      if(!tile)
+        continue;
+      if(tile->getAttributes() & Tile::SOLID)
+        return false;
     }
+  }
+
+  for(MovingObjects::const_iterator i = moving_objects.begin();
+      i != moving_objects.end(); ++i) {
+    const MovingObject* moving_object = *i;
+    if(moving_object->get_group() != COLGROUP_STATIC
+        || !moving_object->is_valid())
+      continue;
 
-    movingobject->bbox.move(movingobject->get_movement());
-    movingobject->movement = Vector(0, 0);
+    if(Collision::intersects(rect, moving_object->get_bbox()))
+      return false;
   }
-#endif
+
+  return true;
 }
 
 bool
@@ -756,11 +1091,11 @@ Sector::add_bullet(const Vector& pos, float xm, Direction dir)
   static const size_t MAX_ICE_BULLETS = 1;
 
   Bullet* new_bullet = 0;
-  if(player_status.bonus == FIRE_BONUS) {
+  if(player_status->bonus == FIRE_BONUS) {
     if(bullets.size() > MAX_FIRE_BULLETS-1)
       return false;
     new_bullet = new Bullet(pos, xm, dir, FIRE_BULLET);
-  } else if(player_status.bonus == ICE_BONUS) {
+  } else if(player_status->bonus == ICE_BONUS) {
     if(bullets.size() > MAX_ICE_BULLETS-1)
       return false;
     new_bullet = new Bullet(pos, xm, dir, ICE_BULLET);
@@ -793,11 +1128,14 @@ Sector::play_music(MusicType type)
   currentmusic = type;
   switch(currentmusic) {
     case LEVEL_MUSIC:
-      sound_manager->play_music(std::string("music/") + song_title);
+      sound_manager->play_music(music);
       break;
     case HERRING_MUSIC:
       sound_manager->play_music("music/salcon.ogg");
       break;
+    case HERRING_WARNING_MUSIC:
+      sound_manager->stop_music(TUX_INVINCIBLE_TIME_WARNING);
+      break;
     default:
       sound_manager->play_music("");
       break;