X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fbadguy%2Fdispenser.cpp;h=32498562db2b2c77268ed7ae8829952f3230900a;hb=602300381571005b3048760e76f8e7acdce39cf8;hp=5f18cc77ba5122b2715a58efe0c207e3d7242be2;hpb=ef57479f613b900b73eba8e8f4d026aae0de25cc;p=supertux.git

diff --git a/src/badguy/dispenser.cpp b/src/badguy/dispenser.cpp
index 5f18cc77b..32498562d 100644
--- a/src/badguy/dispenser.cpp
+++ b/src/badguy/dispenser.cpp
@@ -1,94 +1,246 @@
-#include <config.h>
+//  SuperTux
+//  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 as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  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, see <http://www.gnu.org/licenses/>.
 
-#include "dispenser.h"
-#include "badguy/bouncing_snowball.h"
-#include "badguy/snowball.h"
-#include "badguy/mrbomb.h"
-#include "badguy/mriceblock.h"
+#include "badguy/dispenser.hpp"
 
-Dispenser::Dispenser(const lisp::Lisp& reader)
+#include "audio/sound_manager.hpp"
+#include "math/random_generator.hpp"
+#include "object/bullet.hpp"
+#include "object/player.hpp"
+#include "supertux/object_factory.hpp"
+#include "supertux/sector.hpp"
+#include "util/reader.hpp"
+
+#include <stdexcept>
+
+Dispenser::Dispenser(const Reader& reader) :
+  BadGuy(reader, "images/creatures/dispenser/dispenser.sprite"),
+  cycle(),
+  badguys(),
+  next_badguy(),
+  dispense_timer(),
+  autotarget(),
+  swivel(),
+  broken(),
+  random(),
+  type()
 {
-  reader.get("x", start_position.x);
-  reader.get("y", start_position.y);
+  set_colgroup_active(COLGROUP_MOVING_STATIC);
+  sound_manager->preload("sounds/squish.wav");
   reader.get("cycle", cycle);
-  reader.get("badguy", badguy);
-  bbox.set_size(32, 32);
-  sprite = sprite_manager->create("dispenser");
-  sprite->set_action("working");
-}
+  reader.get("badguy", badguys);
+  random = false; // default
+  reader.get("random", random);
+  type = "dropper"; //default
+  reader.get("type", type);
+  next_badguy = 0;
+  autotarget = false;
+  swivel = false;
+  broken = false;
 
-void
-Dispenser::write(lisp::Writer& writer)
-{
-  writer.start_list("dispenser");
+  if (badguys.size() <= 0)
+    throw std::runtime_error("No badguys in dispenser.");
+
+  if (type == "rocketlauncher") {
+    sprite->set_action(dir == LEFT ? "working-left" : "working-right");
+    set_colgroup_active(COLGROUP_MOVING); //if this were COLGROUP_MOVING_STATIC MrRocket would explode on launch.
 
-  writer.write_float("x", get_pos().x);
-  writer.write_float("y", get_pos().y);
-  writer.write_float("cycle", cycle);
-  writer.write_string("badguy", badguy);
+    if (start_dir == AUTO) {
+      autotarget = true;
+    }
+  } else if (type == "cannon") {
+    sprite->set_action("working");
+  } else {
+    sprite->set_action("dropper");
+  }
 
-  writer.end_list("dispenser");
+  bbox.set_size(sprite->get_current_hitbox_width(), sprite->get_current_hitbox_height());
+  countMe = false;
 }
 
 void
 Dispenser::activate()
-{  
-   dispense_timer.start(cycle, true);
-   launch_badguy();
+{
+  if( broken ){
+    return;
+  }
+  if( autotarget && !swivel ){ // auto cannon sprite might be wrong
+    Player* player = this->get_nearest_player();
+    if( player ){
+      dir = (player->get_pos().x > get_pos().x) ? RIGHT : LEFT;
+      sprite->set_action(dir == LEFT ? "working-left" : "working-right");
+    }
+  }
+  dispense_timer.start(cycle, true);
+  launch_badguy();
 }
 
+void
+Dispenser::deactivate()
+{
+  dispense_timer.stop();
+}
+
+//TODO: Add launching velocity to certain badguys
 bool
-Dispenser::collision_squished(Player& player)
+Dispenser::collision_squished(GameObject& object)
 {
-  //FIXME: Should act like a normal tile when killed
-  sprite->set_action("broken");
+  //Cannon launching MrRocket can be broken by jumping on it
+  //other dispensers are not that fragile.
+  if (broken || type != "rocketlauncher") {
+    return false;
+  }
+
+  sprite->set_action(dir == LEFT ? "broken-left" : "broken-right");
   dispense_timer.start(0);
-  player.bounce(*this);
+  set_colgroup_active(COLGROUP_MOVING_STATIC); // Tux can stand on broken cannon.
+  Player* player = dynamic_cast<Player*>(&object);
+  if (player){
+    player->bounce(*this);
+  }
+  sound_manager->play("sounds/squish.wav", get_pos());
+  broken = true;
   return true;
 }
 
-void
-Dispenser::active_action(float )
+HitResponse
+Dispenser::collision(GameObject& other, const CollisionHit& hit)
 {
-  if (dispense_timer.check()) {
-    launch_badguy();
+  Player* player = dynamic_cast<Player*> (&other);
+  if(player) {
+    // hit from above?
+    if (player->get_bbox().p2.y < (bbox.p1.y + 16)) {
+      collision_squished(*player);
+      return FORCE_MOVE;
+    }
+    if(frozen){
+      unfreeze();
+    }
+    return FORCE_MOVE;
+  }
+
+  Bullet* bullet = dynamic_cast<Bullet*> (&other);
+  if(bullet){
+    return collision_bullet(*bullet, hit);
   }
+
+  return FORCE_MOVE;
 }
 
-HitResponse
-Dispenser::collision_solid(GameObject& , const CollisionHit& hit)
+void
+Dispenser::active_update(float )
 {
-  if(fabsf(hit.normal.y) > .5) { // hit floor or roof?
-    physic.set_velocity_y(0);
-  } else { // hit right or left
-    dir = dir == LEFT ? RIGHT : LEFT;
-    sprite->set_action(dir == LEFT ? "left" : "right");
-    physic.set_velocity_x(-physic.get_velocity_x());
-  }
+  if (dispense_timer.check()) {
+    // auto always shoots in Tux's direction
+    if( autotarget ){ 
+      if( sprite->animation_done()) {
+        sprite->set_action(dir == LEFT ? "working-left" : "working-right");
+        swivel = false;
+      }
 
-  return CONTINUE;
+      Player* player = this->get_nearest_player();
+      if( player && !swivel ){
+        Direction targetdir = (player->get_pos().x > get_pos().x) ? RIGHT : LEFT;
+        if( dir != targetdir ){ // no target: swivel cannon 
+          swivel = true;
+          dir = targetdir;
+          sprite->set_action(dir == LEFT ? "swivel-left" : "swivel-right", 1);
+        } else { // tux in sight: shoot
+          launch_badguy();
+        }
+      }
+    } else {
+      launch_badguy();
+    }
+  }
 }
 
-//TODO: Add launching velocity to badguys
-//      Add randomizer
-//      Clean up stuff I copied without understanding what it does :)
-//      Stop dispensing when game is paused (timer related problem)
-//      Lots-O-Stuff (tm)
 void
 Dispenser::launch_badguy()
 {
   //FIXME: Does is_offscreen() work right here?
   if (!is_offscreen()) {
-    if (badguy == "snowball")
-      Sector::current()->add_object(new SnowBall(get_pos().x, get_pos().y, dir));
-    else if (badguy == "bouncingsnowball")
-      Sector::current()->add_object(new BouncingSnowball(get_pos().x, get_pos().y, dir));
-    else if (badguy == "mrbomb")
-      Sector::current()->add_object(new MrBomb(get_pos().x, get_pos().y, dir));
-    else if (badguy == "mriceblock")
-      Sector::current()->add_object(new MrIceBlock(get_pos().x, get_pos().y, dir));
-    else if (badguy == "random")
-    {}
+    Direction launchdir = dir;
+    if( !autotarget && start_dir == AUTO ){
+      Player* player = this->get_nearest_player();
+      if( player ){
+        launchdir = (player->get_pos().x > get_pos().x) ? RIGHT : LEFT;
+      } 
+    } 
+
+    if (badguys.size() > 1) {
+      if (random) {
+        next_badguy = gameRandom.rand(badguys.size());
+      }
+      else {
+        next_badguy++;
+
+        if (next_badguy >= badguys.size())
+          next_badguy = 0;
+      }
+    }
+
+    std::string badguy = badguys[next_badguy];
+
+    if(badguy == "random") {
+      log_warning << "random is outdated; use a list of badguys to select from." << std::endl;
+      return;
+    }
+
+    GameObject* badguy_object = NULL;
+
+    try {
+      Vector spawnpoint;
+
+      if (type == "dropper")
+        spawnpoint = Vector(get_pos().x, get_pos().y+32);
+      else if (type == "cannon")
+        spawnpoint = Vector(get_pos().x + (launchdir == LEFT ? -32 : 32), get_pos().y);
+      else if (type == "rocketlauncher")
+        spawnpoint = Vector(get_pos().x + (launchdir == LEFT ? -32 : 32), get_pos().y);
+
+      badguy_object = ObjectFactory::instance().create(badguy, spawnpoint, launchdir);
+
+      if (badguy_object)
+        Sector::current()->add_object(badguy_object);
+    } catch(std::exception& e) {
+      log_warning << "Error dispensing badguy: " << e.what() << std::endl;
+      return;
+    }
   }
 }
 
+void
+Dispenser::freeze()
+{
+  BadGuy::freeze();
+  dispense_timer.stop();
+}
+
+void
+Dispenser::unfreeze()
+{
+  BadGuy::unfreeze();
+  activate();
+}
+
+bool
+Dispenser::is_freezable() const
+{
+  return true;
+}
+
+/* EOF */