X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=src%2Fsector.cpp;h=d828a41c4b3c9f3aa4cff6934fbe067b0c58efd1;hb=d62647592b4ccffa89794af6fa03faaced46999d;hp=69bac355192c9f7c32dbd740d6ee43be2a572ebf;hpb=0676f7c09ab0d99e5b6a3bf74b9e2b62aaa885d4;p=supertux.git

diff --git a/src/sector.cpp b/src/sector.cpp
index 69bac3551..d828a41c4 100644
--- a/src/sector.cpp
+++ b/src/sector.cpp
@@ -26,43 +26,42 @@
 #include <sstream>
 #include <stdexcept>
 
-#include "sector.h"
-#include "player_status.h"
-#include "object/gameobjs.h"
-#include "object/camera.h"
-#include "object/background.h"
-#include "object/particlesystem.h"
-#include "object/particlesystem_absolute.h"
-#include "object/tilemap.h"
-#include "lisp/parser.h"
-#include "lisp/lisp.h"
-#include "lisp/writer.h"
-#include "lisp/list_iterator.h"
-#include "tile.h"
-#include "audio/sound_manager.h"
-#include "game_session.h"
-#include "resources.h"
-#include "statistics.h"
-#include "collision_grid.h"
-#include "collision_grid_iterator.h"
-#include "object_factory.h"
-#include "collision.h"
-#include "spawn_point.h"
-#include "math/rect.h"
-#include "math/aatriangle.h"
-#include "object/coin.h"
-#include "object/block.h"
-#include "object/invisible_block.h"
-#include "object/bullet.h"
-#include "object/text_object.h"
-#include "badguy/jumpy.h"
-#include "badguy/spike.h"
-#include "trigger/sequence_trigger.h"
-#include "player_status.h"
-#include "scripting/script_interpreter.h"
-#include "scripting/sound.h"
-#include "scripting/scripted_object.h"
-#include "scripting/text.h"
+#include "sector.hpp"
+#include "player_status.hpp"
+#include "object/gameobjs.hpp"
+#include "object/camera.hpp"
+#include "object/background.hpp"
+#include "object/particlesystem.hpp"
+#include "object/particlesystem_interactive.hpp"
+#include "object/tilemap.hpp"
+#include "lisp/parser.hpp"
+#include "lisp/lisp.hpp"
+#include "lisp/writer.hpp"
+#include "lisp/list_iterator.hpp"
+#include "tile.hpp"
+#include "audio/sound_manager.hpp"
+#include "game_session.hpp"
+#include "resources.hpp"
+#include "statistics.hpp"
+#include "collision_grid.hpp"
+#include "collision_grid_iterator.hpp"
+#include "object_factory.hpp"
+#include "collision.hpp"
+#include "spawn_point.hpp"
+#include "math/rect.hpp"
+#include "math/aatriangle.hpp"
+#include "object/coin.hpp"
+#include "object/block.hpp"
+#include "object/invisible_block.hpp"
+#include "object/bullet.hpp"
+#include "object/text_object.hpp"
+#include "badguy/jumpy.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
 
@@ -72,11 +71,15 @@ Sector::Sector()
   : gravity(10), player(0), solids(0), camera(0),
     currentmusic(LEVEL_MUSIC)
 {
-  song_title = "Mortimers_chipdisko.mod";
-  player = new Player(&player_status);
+  song_title = "chipdisko.ogg";
+  player = new Player(player_status);
   add_object(player);
 
+#ifdef USE_GRID
   grid = new CollisionGrid(32000, 32000);
+#else
+  grid = 0;
+#endif
 }
 
 Sector::~Sector()
@@ -114,6 +117,14 @@ Sector::parse_object(const std::string& name, const lisp::Lisp& reader)
     RainParticleSystem* partsys = new RainParticleSystem();
     partsys->parse(reader);
     return partsys;
+  } else if(name == "particles-comets") {
+    CometParticleSystem* partsys = new CometParticleSystem();
+    partsys->parse(reader);
+    return partsys;
+  } else if(name == "particles-ghosts") {
+    GhostParticleSystem* partsys = new GhostParticleSystem();
+    partsys->parse(reader);
+    return partsys;
   } else if(name == "particles-clouds") {
     CloudParticleSystem* partsys = new CloudParticleSystem();
     partsys->parse(reader);
@@ -145,7 +156,6 @@ Sector::parse(const lisp::Lisp& sector)
       iter.value()->get(gravity);
     } else if(token == "music") {
       iter.value()->get(song_title);
-      load_music();
     } else if(token == "spawnpoint") {
       SpawnPoint* sp = new SpawnPoint(iter.lisp());
       spawnpoints.push_back(sp);
@@ -160,14 +170,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";
     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();
 }
@@ -191,16 +203,16 @@ 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;
@@ -230,11 +242,10 @@ Sector::parse_old_format(const lisp::Lisp& reader)
   spawn->name = "main";
   spawnpoints.push_back(spawn);
 
-  song_title = "Mortimers_chipdisko.mod";
+  song_title = "chipdisko.ogg";
   reader.get("music", song_title);
-  load_music();
 
-  int width, height = 15;
+  int width = 30, height = 15;
   reader.get("width", width);
   reader.get("height", height);
   
@@ -297,10 +308,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
@@ -315,18 +328,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);
@@ -341,7 +342,7 @@ Sector::fix_old_tiles()
         add_object(new SequenceTrigger(pos, sequence));
         solids->change(x, y, 0);
       }
-    }                                                   
+    }
   }
 }
 
@@ -418,19 +419,8 @@ Sector::activate(const std::string& spawnpoint)
 
   // Run init script
   if(init_script != "") {
-    try {
-      ScriptInterpreter* interpreter 
-        = new ScriptInterpreter(GameSession::current()->get_working_directory());
-      interpreter->register_sector(this);
-      std::string sourcename = std::string("Sector(") + name + ") - init";
-      std::istringstream in(init_script);
-      interpreter->load_script(in, sourcename);
-      interpreter->start_script();
-      add_object(interpreter);
-      init_script = "";
-    } catch(std::exception& e) {
-      std::cerr << "Couldn't execute init script: " << e.what() << "\n";
-    }
+    ScriptInterpreter::add_script_object(this,
+        std::string("Sector(") + name + ") - init", init_script);
   }
 }
 
@@ -477,7 +467,7 @@ Sector::update(float elapsed_time)
 #endif
   
   /* Handle all possible collisions. */
-  collision_handler();                                                                              
+  handle_collisions();
   update_game_objects();
 }
 
@@ -485,6 +475,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;
@@ -494,16 +508,6 @@ Sector::update_game_objects()
       continue;
     }
     
-    Bullet* bullet = dynamic_cast<Bullet*> (object);
-    if(bullet) {
-      bullets.erase(
-          std::remove(bullets.begin(), bullets.end(), bullet),
-          bullets.end());
-    }
-    MovingObject* movingobject = dynamic_cast<MovingObject*> (object);
-    if(movingobject) {
-      grid->remove_object(movingobject);
-    }
     delete *i;
     i = gameobjects.erase(i);
   }
@@ -519,8 +523,12 @@ Sector::update_game_objects()
       bullets.push_back(bullet);
 
     MovingObject* movingobject = dynamic_cast<MovingObject*> (object);
-    if(movingobject)
+    if(movingobject) {
+      moving_objects.push_back(movingobject);
+ #ifdef USE_GRID
       grid->add_object(movingobject);
+#endif
+    }
     
     TileMap* tilemap = dynamic_cast<TileMap*> (object);
     if(tilemap && tilemap->is_solid()) {
@@ -610,9 +618,10 @@ Sector::collision_tilemap(MovingObject* object, int depth)
   int max_x = int(x2+1);
   int max_y = int(y2+1);
 
-  CollisionHit temphit, hit;
+  TilemapCollisionHit temphit, hit;
   Rect dest = object->get_bbox();
   dest.move(object->movement);
+  hit.tileflags = 0;
   hit.time = -1; // represents an invalid value
   for(int x = starttilex; x*32 < max_x; ++x) {
     for(int y = starttiley; y*32 < max_y; ++y) {
@@ -620,7 +629,7 @@ Sector::collision_tilemap(MovingObject* object, int depth)
       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
@@ -637,22 +646,28 @@ Sector::collision_tilemap(MovingObject* object, int depth)
 
         if(Collision::rectangle_aatriangle(temphit, dest, object->movement,
               triangle)) {
-          if(temphit.time > hit.time)
+          hit.tileflags |= tile->getAttributes();
+          if(temphit.time > hit.time && (tile->getAttributes() & Tile::SOLID)) {
+            temphit.tileflags = hit.tileflags;
             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)
+          hit.tileflags |= tile->getAttributes();
+          if(temphit.time > hit.time && (tile->getAttributes() & Tile::SOLID)) {
+            temphit.tileflags = hit.tileflags;
             hit = temphit;
+          }
         }
       }
     }
   }
 
   // did we collide at all?
-  if(hit.time < 0)
+  if(hit.tileflags == 0)
     return;
  
   // call collision function
@@ -702,18 +717,87 @@ Sector::collision_object(MovingObject* object1, MovingObject* object2)
 }
 
 void
-Sector::collision_handler()
+Sector::handle_collisions()
 {
 #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())
+  // part1: COLGROUP_MOVING vs COLGROUP_STATIC and tilemap
+  for(MovingObjects::iterator i = moving_objects.begin();
+      i != moving_objects.end(); ++i) {
+    MovingObject* movingobject = *i;
+    if(movingobject->get_group() != COLGROUP_MOVING
+        || !movingobject->is_valid())
       continue;
-    MovingObject* movingobject = dynamic_cast<MovingObject*> (gameobject);
-    if(!movingobject)
+
+    // collision with tilemap
+    collision_tilemap(movingobject, 0);
+   
+    // collision with other objects
+    for(MovingObjects::iterator i2 = i+1;
+        i2 != moving_objects.end(); ++i2) {
+      MovingObject* movingobject2 = *i2;
+      if(movingobject2->get_group() != COLGROUP_STATIC
+         || !movingobject2->is_valid())
+        continue;
+
+      collision_object(movingobject, movingobject2);
+    }
+  }
+
+  // part2: 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;
+
+    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;
+
+      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(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.move(moving_object->get_movement());
+    moving_object->movement = Vector(0, 0);
+  }
+ 
+#if 0
+  for(MovingObjects::iterator i = moving_objects.begin();
+      i != moving_objects.end(); ++i) {
+    MovingObject* movingobject = *i;
+    if(!movingobject->is_valid())
       continue;
     if(movingobject->get_flags() & GameObject::FLAG_NO_COLLDET) {
       movingobject->bbox.move(movingobject->movement);
@@ -726,14 +810,11 @@ Sector::collision_handler()
       collision_tilemap(movingobject, 0);
 
     // 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)
-        continue;
-      MovingObject* movingobject2 = dynamic_cast<MovingObject*> (other_object);
-      if(!movingobject2)
+    for(MovingObjects::iterator i2 = i+1;
+        i2 != moving_objects.end(); ++i2) {
+      MovingObject* movingobject2 = *i2;
+      if(!movingobject2->is_valid()
+          || movingobject2->get_flags() & GameObject::FLAG_NO_COLLDET)
         continue;
 
       collision_object(movingobject, movingobject2);
@@ -743,6 +824,8 @@ Sector::collision_handler()
     movingobject->movement = Vector(0, 0);
   }
 #endif
+  
+#endif
 }
 
 bool
@@ -753,11 +836,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);
@@ -766,7 +849,7 @@ Sector::add_bullet(const Vector& pos, float xm, Direction dir)
   }
   add_object(new_bullet);
 
-  sound_manager->play_sound("shoot");
+  sound_manager->play("sounds/shoot.wav");
 
   return true;
 }
@@ -785,25 +868,18 @@ Sector::add_floating_text(const Vector& pos, const std::string& text)
 }
 
 void
-Sector::load_music()
-{
-  level_song = sound_manager->load_music(
-    get_resource_filename("/music/" + song_title));
-}
-
-void
 Sector::play_music(MusicType type)
 {
   currentmusic = type;
   switch(currentmusic) {
     case LEVEL_MUSIC:
-      sound_manager->play_music(level_song);
+      sound_manager->play_music(std::string("music/") + song_title);
       break;
     case HERRING_MUSIC:
-      sound_manager->play_music(herring_song);
+      sound_manager->play_music("music/salcon.ogg");
       break;
     default:
-      sound_manager->halt_music();
+      sound_manager->play_music("");
       break;
   }
 }