SDL: use hash table for color cache

[supertux.git] / src / sector.cpp

diff --git a/src/sector.cpp b/src/sector.cpp
index 125d186..57418fd 100644 (file)
--- a/src/sector.cpp
+++ b/src/sector.cpp
@@ -177,6 +177,7 @@ Sector::parse_object(const std::string& name, const lisp::Lisp& reader)
 void
 Sector::parse(const lisp::Lisp& sector)
 {
+  bool has_background = false;
   lisp::ListIterator iter(&sector);
   while(iter.next()) {
     const std::string& token = iter.item();
@@ -202,11 +203,22 @@ Sector::parse(const lisp::Lisp& sector)
     } else {
       GameObject* object = parse_object(token, *(iter.lisp()));
       if(object) {
+        if(dynamic_cast<Background *>(object)) {
+           has_background = true;
+        } else if(dynamic_cast<Gradient *>(object)) {
+           has_background = true;
+        }
         add_object(object);
       }
     }
   }
 
+  if(!has_background) {
+    Gradient* gradient = new Gradient();
+    gradient->set_gradient(Color(0.3, 0.4, 0.75), Color(1, 1, 1));
+    add_object(gradient);
+  }
+
   update_game_objects();
 
   if(solid_tilemaps.size() < 1) log_warning << "sector '" << name << "' does not contain a solid tile layer." << std::endl;
@@ -684,6 +696,18 @@ Sector::update_game_objects()
     gameobjects.push_back(object);
   }
   gameobjects_new.clear();
+
+  /* update solid_tilemaps list */
+  //FIXME: this could be more efficient
+  solid_tilemaps.clear();
+  for(std::vector<GameObject*>::iterator i = gameobjects.begin();
+      i != gameobjects.end(); ++i)
+  {
+    TileMap* tm = dynamic_cast<TileMap*>(*i);
+    if (!tm) continue;
+    if (tm->is_solid()) solid_tilemaps.push_back(tm);
+  }
+
 }
 
 bool
@@ -865,11 +889,18 @@ void check_collisions(collision::Constraints* constraints,
   if(!collision::intersects(r1, r2))
     return;
 
+  MovingObject *moving_object = dynamic_cast<MovingObject*> (object);
+  CollisionHit dummy;
+  if(other != NULL && !other->collides(*object, dummy))
+    return;
+  if(moving_object != NULL && !moving_object->collides(*other, dummy))
+    return;
+
   // calculate intersection
-  float itop = r1.get_bottom() - r2.get_top();
+  float itop    = r1.get_bottom() - r2.get_top();
   float ibottom = r2.get_bottom() - r1.get_top();
-  float ileft = r1.get_right() - r2.get_left();
-  float iright = r2.get_right() - r1.get_left();
+  float ileft   = r1.get_right() - r2.get_left();
+  float iright  = r2.get_right() - r1.get_left();
 
   if(fabsf(movement.y) > fabsf(movement.x)) {
     if(ileft < SHIFT_DELTA) {
@@ -891,10 +922,10 @@ void check_collisions(collision::Constraints* constraints,
   }
 
   if(other != NULL) {
-    CollisionHit dummy;
     HitResponse response = other->collision(*object, dummy);
     if(response == PASSTHROUGH)
       return;
+
     if(other->get_movement() != Vector(0, 0)) {
       // TODO what todo when we collide with 2 moving objects?!?
       constraints->ground_movement = other->get_movement();
@@ -1048,12 +1079,19 @@ Sector::collision_object(MovingObject* object1, MovingObject* object2) const
     Vector normal;
     get_hit_normal(r1, r2, hit, normal);
 
+    if(!object1->collides(*object2, hit))
+      return;
+    std::swap(hit.left, hit.right);
+    std::swap(hit.top, hit.bottom);
+    if(!object2->collides(*object1, hit))
+      return;
+    std::swap(hit.left, hit.right);
+    std::swap(hit.top, hit.bottom);
+
     HitResponse response1 = object1->collision(*object2, hit);
     std::swap(hit.left, hit.right);
     std::swap(hit.top, hit.bottom);
     HitResponse response2 = object2->collision(*object1, hit);
-    assert( response1 != SOLID && response1 != PASSTHROUGH );
-    assert( response2 != SOLID && response2 != PASSTHROUGH );
     if(response1 == CONTINUE && response2 == CONTINUE) {
       normal *= (0.5 + DELTA);
       object1->dest.move(-normal);
@@ -1144,8 +1182,10 @@ Sector::collision_static_constrains(MovingObject& object)
     if(constraints.right < infinity) {
       float width = constraints.right - constraints.left;
       if(width + SHIFT_DELTA < owidth) {
+#if 0
         printf("Object %p crushed horizontally... L:%f R:%f\n", &object,
             constraints.left, constraints.right);
+#endif
         CollisionHit h;
         h.left = true;
         h.right = true;
@@ -1174,7 +1214,9 @@ Sector::collision_static_constrains(MovingObject& object)
   if(constraints.bottom < infinity) {
     float height = constraints.bottom - constraints.top;
     if(height + SHIFT_DELTA < oheight) {
+#if 0
       printf("Object %p crushed vertically...\n", &object);
+#endif
       CollisionHit h;
       h.top = true;
       h.bottom = true;
@@ -1260,6 +1302,11 @@ Sector::handle_collisions()
         CollisionHit hit;
         get_hit_normal(moving_object->dest, moving_object_2->dest,
                        hit, normal);
+        if(!moving_object->collides(*moving_object_2, hit))
+          continue;
+        if(!moving_object_2->collides(*moving_object, hit))
+          continue;
+
         moving_object->collision(*moving_object_2, hit);
         moving_object_2->collision(*moving_object, hit);
       }
@@ -1448,7 +1495,9 @@ Sector::inside(const Rect& rect) const
     TileMap* solids = *i;
     bool horizontally = ((rect.p2.x >= 0 + solids->get_x_offset()) && (rect.p1.x <= solids->get_width() * 32 + solids->get_x_offset()));
     bool vertically = (rect.p1.y <= solids->get_height() * 32 + solids->get_y_offset());
-    if (horizontally && vertically) return true;
+
+    if (horizontally && vertically)
+      return true;
   }
   return false;
 }
@@ -1457,10 +1506,14 @@ float
 Sector::get_width() const
 {
   float width = 0;
-  for(std::list<TileMap*>::const_iterator i = solid_tilemaps.begin(); i != solid_tilemaps.end(); i++) {
+  for(std::list<TileMap*>::const_iterator i = solid_tilemaps.begin();
+      i != solid_tilemaps.end(); i++) {
     TileMap* solids = *i;
-    if ((solids->get_width() * 32 + solids->get_x_offset()) > width) width = (solids->get_width() * 32 + solids->get_x_offset());
+    if ((solids->get_width() * 32 + solids->get_x_offset()) > width) {
+      width = solids->get_width() * 32 + solids->get_x_offset();
+    }
   }
+
   return width;
 }
 
@@ -1468,10 +1521,14 @@ float
 Sector::get_height() const
 {
   float height = 0;
-  for(std::list<TileMap*>::const_iterator i = solid_tilemaps.begin(); i != solid_tilemaps.end(); i++) {
+  for(std::list<TileMap*>::const_iterator i = solid_tilemaps.begin();
+      i != solid_tilemaps.end(); i++) {
     TileMap* solids = *i;
-    if ((solids->get_height() * 32 + solids->get_y_offset()) > height) height = (solids->get_height() * 32 + solids->get_y_offset());
+    if ((solids->get_height() * 32 + solids->get_y_offset()) > height) {
+      height = solids->get_height() * 32 + solids->get_y_offset();
+    }
   }
+
   return height;
 }