Removed Kirby badguy code, use simple sprite replacement in the level instead

[supertux.git] / src / badguy / walking_badguy.cpp

diff --git a/src/badguy/walking_badguy.cpp b/src/badguy/walking_badguy.cpp
index d5e3426..5e26d49 100644 (file)
--- a/src/badguy/walking_badguy.cpp
+++ b/src/badguy/walking_badguy.cpp
@@ -20,46 +20,46 @@
 
 #include "sprite/sprite.hpp"
 
-WalkingBadguy::WalkingBadguy(const Vector& pos, 
-                             const std::string& sprite_name, 
-                             const std::string& walk_left_action, 
-                             const std::string& walk_right_action, 
-                             int layer) :
-  BadGuy(pos, sprite_name, layer), 
-  walk_left_action(walk_left_action), 
-  walk_right_action(walk_right_action), 
-  walk_speed(80), 
+WalkingBadguy::WalkingBadguy(const Vector& pos,
+                             const std::string& sprite_name_,
+                             const std::string& walk_left_action_,
+                             const std::string& walk_right_action_,
+                             int layer_) :
+  BadGuy(pos, sprite_name_, layer_),
+  walk_left_action(walk_left_action_),
+  walk_right_action(walk_right_action_),
+  walk_speed(80),
   max_drop_height(-1),
   turn_around_timer(),
   turn_around_counter()
 {
 }
 
-WalkingBadguy::WalkingBadguy(const Vector& pos, 
-                             Direction direction, 
-                             const std::string& sprite_name, 
-                             const std::string& walk_left_action, 
-                             const std::string& walk_right_action, 
-                             int layer) :
-  BadGuy(pos, direction, sprite_name, layer), 
-  walk_left_action(walk_left_action), 
-  walk_right_action(walk_right_action), 
-  walk_speed(80), 
+WalkingBadguy::WalkingBadguy(const Vector& pos,
+                             Direction direction,
+                             const std::string& sprite_name_,
+                             const std::string& walk_left_action_,
+                             const std::string& walk_right_action_,
+                             int layer_) :
+  BadGuy(pos, direction, sprite_name_, layer_),
+  walk_left_action(walk_left_action_),
+  walk_right_action(walk_right_action_),
+  walk_speed(80),
   max_drop_height(-1),
   turn_around_timer(),
   turn_around_counter()
 {
 }
 
-WalkingBadguy::WalkingBadguy(const Reader& reader, 
-                             const std::string& sprite_name, 
-                             const std::string& walk_left_action, 
-                             const std::string& walk_right_action, 
-                             int layer) :
-  BadGuy(reader, sprite_name, layer), 
-  walk_left_action(walk_left_action), 
-  walk_right_action(walk_right_action), 
-  walk_speed(80), 
+WalkingBadguy::WalkingBadguy(const Reader& reader,
+                             const std::string& sprite_name_,
+                             const std::string& walk_left_action_,
+                             const std::string& walk_right_action_,
+                             int layer_) :
+  BadGuy(reader, sprite_name_, layer_),
+  walk_left_action(walk_left_action_),
+  walk_right_action(walk_right_action_),
+  walk_speed(80),
   max_drop_height(-1),
   turn_around_timer(),
   turn_around_counter()
@@ -91,23 +91,44 @@ WalkingBadguy::add_velocity (const Vector& velocity)
 }
 
 void
-WalkingBadguy::active_update(float elapsed_time)
+WalkingBadguy::active_update(float elapsed_time, float dest_x_velocity)
 {
   BadGuy::active_update(elapsed_time);
 
-  float abs_cur_walk_speed = fabs (physic.get_velocity_x ());
-  if ((abs_cur_walk_speed > (walk_speed - 5.0))
-      && (abs_cur_walk_speed < (walk_speed + 5.0)))
+  float current_x_velocity = physic.get_velocity_x ();
+
+  if (frozen)
   {
-    physic.set_velocity_x ((dir == LEFT) ? -walk_speed : +walk_speed);
+    physic.set_velocity_x (0.0);
     physic.set_acceleration_x (0.0);
   }
-  /* acceleration == walk-speed => it will take one second to get from zero to full speed. */
-  else if (abs_cur_walk_speed < walk_speed) {
-    physic.set_acceleration_x ((dir == LEFT) ? -walk_speed : +walk_speed);
+  /* We're very close to our target speed. Just set it to avoid oscillation */
+  else if ((current_x_velocity > (dest_x_velocity - 5.0))
+      && (current_x_velocity < (dest_x_velocity + 5.0)))
+  {
+    physic.set_velocity_x (dest_x_velocity);
+    physic.set_acceleration_x (0.0);
   }
-  else if (abs_cur_walk_speed > walk_speed) {
-    physic.set_acceleration_x ((dir == LEFT) ? +walk_speed : -walk_speed);
+  /* Check if we're going too slow or even in the wrong direction */
+  else if (((dest_x_velocity <= 0.0) && (current_x_velocity > dest_x_velocity))
+      || ((dest_x_velocity > 0.0) && (current_x_velocity < dest_x_velocity)))
+  {
+    /* acceleration == walk-speed => it will take one second to get from zero
+     * to full speed. */
+    physic.set_acceleration_x (dest_x_velocity);
+  }
+  /* Check if we're going too fast */
+  else if (((dest_x_velocity <= 0.0) && (current_x_velocity < dest_x_velocity))
+      || ((dest_x_velocity > 0.0) && (current_x_velocity > dest_x_velocity)))
+  {
+    /* acceleration == walk-speed => it will take one second to get twice the
+     * speed to normal speed. */
+    physic.set_acceleration_x ((-1.0) * dest_x_velocity);
+  }
+  else
+  {
+    /* The above should have covered all cases. */
+    assert (23 == 42);
   }
 
   if (max_drop_height > -1) {
@@ -116,6 +137,21 @@ WalkingBadguy::active_update(float elapsed_time)
       turn_around();
     }
   }
+
+  if ((dir == LEFT) && (physic.get_velocity_x () > 0.0)) {
+    dir = RIGHT;
+    set_action (walk_right_action, /* loops = */ -1);
+  }
+  else if ((dir == RIGHT) && (physic.get_velocity_x () < 0.0)) {
+    dir = LEFT;
+    set_action (walk_left_action, /* loops = */ -1);
+  }
+}
+
+void
+WalkingBadguy::active_update(float elapsed_time)
+{
+  this->active_update (elapsed_time, (dir == LEFT) ? -walk_speed : +walk_speed);
 }
 
 void