X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fsector.cpp;h=3a0e2299d84253018905f7fd3100cc00b065195e;hb=c62711567861587107d124642db29e2674ee6533;hp=9e33ce7c0da3b8116c97e8f45d48286ca832497b;hpb=1d63ad0dfe0eedf89191627be00b2b3b1215c311;p=supertux.git

diff --git a/src/sector.cpp b/src/sector.cpp
index 9e33ce7c0..3a0e2299d 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
@@ -32,6 +32,7 @@
 #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"
@@ -59,46 +60,73 @@
 #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"
-#include "msg.hpp"
+#include "scripting/squirrel_util.hpp"
+#include "script_interface.hpp"
+#include "log.hpp"
 
 Sector* Sector::_current = 0;
 
-Sector::Sector()
-  : gravity(10), player(0), solids(0), camera(0),
-    currentmusic(LEVEL_MUSIC)
+bool Sector::show_collrects = false;
+bool Sector::draw_solids_only = false;
+
+Sector::Sector(Level* parent)
+  : level(parent), currentmusic(LEVEL_MUSIC), gravity(10),
+    player(0), solids(0), camera(0)
 {
-  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
+
+  // create a new squirrel table for the sector
+  using namespace Scripting;
+
+  sq_newtable(global_vm);
+  sq_pushroottable(global_vm);
+  if(SQ_FAILED(sq_setdelegate(global_vm, -2)))
+    throw Scripting::SquirrelError(global_vm, "Couldn't set sector_table delegate");
+
+  sq_resetobject(&sector_table);
+  if(SQ_FAILED(sq_getstackobj(global_vm, -1, &sector_table)))
+    throw Scripting::SquirrelError(global_vm, "Couldn't get sector table");
+  sq_addref(global_vm, &sector_table);
+  sq_pop(global_vm, 1);
 }
 
 Sector::~Sector()
 {
+  using namespace Scripting;
+  
+  deactivate();
+
+  for(ScriptList::iterator i = scripts.begin();
+      i != scripts.end(); ++i) {
+    HSQOBJECT& object = *i;
+    sq_release(global_vm, &object);
+  }
+  sq_release(global_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;
+}
+
+Level*
+Sector::get_level()
+{
+  return level;
 }
 
 GameObject*
@@ -135,7 +163,7 @@ Sector::parse_object(const std::string& name, const lisp::Lisp& reader)
   try {
     return create_object(name, reader);
   } catch(std::exception& e) {
-    msg_warning(e.what() << "");
+    log_warning << e.what() << "" << std::endl;
   }
   
   return 0;
@@ -143,9 +171,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();
@@ -175,7 +201,7 @@ Sector::parse(const lisp::Lisp& sector)
 
   fix_old_tiles();
   if(!camera) {
-    msg_warning("sector '" << name << "' does not contain a camera.");
+    log_warning << "sector '" << name << "' does not contain a camera." << std::endl;
     update_game_objects();
     add_object(new Camera(this));
   }
@@ -186,8 +212,6 @@ Sector::parse(const lisp::Lisp& sector)
 void
 Sector::parse_old_format(const lisp::Lisp& reader)
 {
-  _current = this;
-  
   name = "main";
   reader.get("gravity", gravity);
 
@@ -214,14 +238,14 @@ Sector::parse_old_format(const lisp::Lisp& reader)
   bkgd_bottom.blue = static_cast<float> (b) / 255.0f;
   
   if(backgroundimage != "") {
-    Background* background = new Background;
+    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;
@@ -285,7 +309,7 @@ Sector::parse_old_format(const lisp::Lisp& reader)
           spawnpoints.push_back(sp);
           }
       } else {
-        msg_warning("Unknown token '" << iter.item() << "' in reset-points.");
+        log_warning << "Unknown token '" << iter.item() << "' in reset-points." << std::endl;
       }
     }
   }
@@ -299,7 +323,7 @@ Sector::parse_old_format(const lisp::Lisp& reader)
       if(object) {
         add_object(object);
       } else {
-        msg_warning("Unknown object '" << iter.item() << "' in level.");
+        log_warning << "Unknown object '" << iter.item() << "' in level." << std::endl;
       }
     }
   }
@@ -374,6 +398,40 @@ Sector::write(lisp::Writer& writer)
   }
 }
 
+HSQUIRRELVM
+Sector::run_script(std::istream& in, const std::string& sourcename)
+{
+  using namespace Scripting;
+
+  // garbage collect thread list
+  for(ScriptList::iterator i = scripts.begin();
+      i != scripts.end(); ) {
+    HSQOBJECT& object = *i;
+    HSQUIRRELVM vm = object_to_vm(object);
+
+    if(sq_getvmstate(vm) != SQ_VMSTATE_SUSPENDED) {
+      sq_release(global_vm, &object);
+      i = scripts.erase(i);
+      continue;
+    }
+    
+    ++i;
+  }
+  
+  HSQOBJECT object = create_thread(global_vm);
+  scripts.push_back(object);
+
+  HSQUIRRELVM vm = object_to_vm(object);
+
+  // set sector_table as roottable for the thread
+  sq_pushobject(vm, sector_table);
+  sq_setroottable(vm);
+
+  compile_and_run(vm, in, sourcename);
+
+  return vm;
+}
+
 void
 Sector::add_object(GameObject* object)
 {
@@ -408,7 +466,7 @@ Sector::activate(const std::string& spawnpoint)
     }
   }                                                                           
   if(!sp) {
-    msg_warning("Spawnpoint '" << spawnpoint << "' not found.");
+    log_warning << "Spawnpoint '" << spawnpoint << "' not found." << std::endl;
     if(spawnpoint != "main") {
       activate("main");
     } else {
@@ -417,21 +475,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 = Scripting::global_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;
+
+  // remove sector entry from global vm
+  HSQUIRRELVM vm = Scripting::global_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);
+  }
 
-  player->move(player_pos);
-  camera->reset(player->get_pos());
+  _current = NULL;
 }
 
 Rect
@@ -508,6 +611,8 @@ Sector::update_game_objects()
       ++i;
       continue;
     }
+
+    before_object_remove(object);
     
     delete *i;
     i = gameobjects.erase(i);
@@ -518,43 +623,100 @@ 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);
-
-    MovingObject* movingobject = dynamic_cast<MovingObject*> (object);
-    if(movingobject) {
-      moving_objects.push_back(movingobject);
- #ifdef USE_GRID
-      grid->add_object(movingobject);
+    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
+    grid->add_object(movingobject);
 #endif
+  }
+  
+  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;
     }
-    
-    TileMap* tilemap = dynamic_cast<TileMap*> (object);
-    if(tilemap && tilemap->is_solid()) {
-      if(solids == 0) {
-        solids = tilemap;
-      } else {
-        msg_warning("Another solid tilemaps added. Ignoring");
-      }
+  }
+
+  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;
+  }
 
-    Camera* camera = dynamic_cast<Camera*> (object);
-    if(camera) {
-      if(this->camera != 0) {
-        msg_warning("Multiple cameras added. Ignoring");
-        continue;
-      }
-      this->camera = camera;
+  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.push_back(object);
+  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 = Scripting::global_vm;
+    sq_pushobject(vm, sector_table);
+    interface->expose(vm, -1);
+    sq_pop(vm, 1);
   }
-  gameobjects_new.clear();
 }
 
 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 = Scripting::global_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();
@@ -565,10 +727,28 @@ Sector::draw(DrawingContext& context)
     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);
   }
 
+  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();
 }
 
@@ -587,9 +767,8 @@ Sector::collision_tilemap(const Rect& dest, const Vector& movement,
   // test with all tiles in this rectangle
   int starttilex = int(x1) / 32;
   int starttiley = int(y1) / 32;
-  int max_x = int(x2);
-  // the +1 is somehow needed to make characters stay on the floor
-  int max_y = int(y2+1);
+  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) {
@@ -665,10 +844,10 @@ Sector::collision_tile_attributes(const Rect& dest) const
   float y2 = dest.p2.y;
 
   // 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);
+  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) {
@@ -729,17 +908,12 @@ Sector::collision_static(MovingObject* object, const Vector& movement)
         || !moving_object_2->is_valid())
       continue;
         
-    Rect dest2 = moving_object_2->get_bbox();
-    // We're using the old position of the object here,
-    // this might seem a bit wrong but improves some situations
-    // like stacked boxes and badguys alot 
-    //
-    dest2.move(moving_object_2->get_movement());
+    Rect dest = moving_object_2->dest;
+
     Vector rel_movement 
       = movement - moving_object_2->get_movement();
-    //Vector movement = 
-        
-    if(Collision::rectangle_rectangle(temphit, object->dest, rel_movement, dest2)
+
+    if(Collision::rectangle_rectangle(temphit, object->dest, rel_movement, dest)
         && temphit.time > hit.time) {
       hit = temphit;
       collided_with = moving_object_2;
@@ -804,18 +978,18 @@ Sector::handle_collisions()
     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)) {
+    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)*/ movement);
+        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)*/ movement);
+        bool res = collision_static(moving_object, Vector(0, movement.y));
         if(res)
           break;
       }
@@ -825,13 +999,13 @@ Sector::handle_collisions()
       // 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, movement/*Vector(0, movement.y)*/);
+        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, movement /*Vector(movement.x, 0)*/);
+        bool res = collision_static(moving_object, Vector(movement.x, 0));
         if(res)
           break;
       }
@@ -911,8 +1085,8 @@ Sector::is_free_space(const Rect& rect) const
   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) {
+  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;
@@ -939,16 +1113,14 @@ bool
 Sector::add_bullet(const Vector& pos, float xm, Direction dir)
 {
   // TODO remove this function and move these checks elsewhere...
-  static const size_t MAX_FIRE_BULLETS = 2;
-  static const size_t MAX_ICE_BULLETS = 1;
 
   Bullet* new_bullet = 0;
   if(player_status->bonus == FIRE_BONUS) {
-    if(bullets.size() > MAX_FIRE_BULLETS-1)
+    if((int)bullets.size() >= player_status->max_fire_bullets)
       return false;
     new_bullet = new Bullet(pos, xm, dir, FIRE_BULLET);
   } else if(player_status->bonus == ICE_BONUS) {
-    if(bullets.size() > MAX_ICE_BULLETS-1)
+    if((int)bullets.size() >= player_status->max_ice_bullets)
       return false;
     new_bullet = new Bullet(pos, xm, dir, ICE_BULLET);
   } else {
@@ -985,6 +1157,9 @@ Sector::play_music(MusicType type)
     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;
@@ -1016,7 +1191,7 @@ Sector::inside(const Rect& rect) const
 {
   if(rect.p1.x > solids->get_width() * 32 
       || rect.p1.y > solids->get_height() * 32
-      || rect.p2.x < 0 || rect.p2.y < 0)
+      || rect.p2.x < 0)
     return false;
 
   return true;