Wind and swimming updates

src/badguy/badguy.cpp

@@ -54,6 +54,8 @@ BadGuy::BadGuy(const Vector& pos, Direction direction, const std::string& sprite
                const std::string& light_sprite_name, const std::string& ice_sprite_name) :
   MovingSprite(pos, sprite_name, layer, COLGROUP_DISABLED),
   m_physic(),
+  m_wind_velocity(),
+  m_wind_acceleration(0.f),
   m_countMe(true),
   m_is_initialized(false),
   m_start_position(m_col.m_bbox.p1()),
@@ -97,6 +99,8 @@ BadGuy::BadGuy(const ReaderMapping& reader, const std::string& sprite_name,
                const std::string& light_sprite_name, const std::string& ice_sprite_name) :
   MovingSprite(reader, sprite_name, layer, COLGROUP_DISABLED),
   m_physic(),
+  m_wind_velocity(),
+  m_wind_acceleration(0.f),
   m_countMe(true),
   m_is_initialized(false),
   m_start_position(m_col.m_bbox.p1()),
@@ -382,6 +386,8 @@ BadGuy::get_allowed_directions() const
 void
 BadGuy::active_update(float dt_sec)
 {
+  handle_wind();
+
   if (!is_grabbed())
   {
     if (is_in_water() && m_water_affected)
@@ -403,6 +409,22 @@ BadGuy::active_update(float dt_sec)
   }
 }
 
+void
+BadGuy::handle_wind()
+{
+  if (!m_col.m_colliding_wind.empty())
+  {
+    if (on_ground() && m_wind_velocity.y > 0.f)
+      m_wind_velocity.y = 0.f;
+
+    m_physic.set_velocity(m_physic.get_velocity() + m_wind_velocity);
+  }
+  else {
+    m_wind_velocity = Vector(0.f, 0.f);
+    m_wind_acceleration = 0.0;
+  }
+}
+
 void
 BadGuy::inactive_update(float )
 {
@@ -1184,21 +1206,29 @@ BadGuy::after_editor_set()
 bool
 BadGuy::can_be_affected_by_wind() const
 {
-  return !on_ground();
+  return true;
 }
 
 void
-BadGuy::add_wind_velocity(const Vector& velocity, const Vector& end_speed)
+BadGuy::add_wind_velocity(const float acceleration, const Vector& end_speed, const float dt_sec)
 {
+  Vector adjusted_end_speed = glm::normalize(end_speed) * acceleration;
+
+  Vector vec_acceleration = adjusted_end_speed * dt_sec;
+
+  m_wind_acceleration = acceleration;
+  Vector end_velocity = Vector(0.f, 0.f);
   // Only add velocity in the same direction as the wind.
-  if (end_speed.x > 0 && m_physic.get_velocity_x() < end_speed.x)
-    m_physic.set_velocity_x(std::min(m_physic.get_velocity_x() + velocity.x, end_speed.x));
-  if (end_speed.x < 0 && m_physic.get_velocity_x() > end_speed.x)
-    m_physic.set_velocity_x(std::max(m_physic.get_velocity_x() + velocity.x, end_speed.x));
-  if (end_speed.y > 0 && m_physic.get_velocity_y() < end_speed.y)
-    m_physic.set_velocity_y(std::min(m_physic.get_velocity_y() + velocity.y, end_speed.y));
-  if (end_speed.y < 0 && m_physic.get_velocity_y() > end_speed.y)
-    m_physic.set_velocity_y(std::max(m_physic.get_velocity_y() + velocity.y, end_speed.y));
+  if (adjusted_end_speed.x > 0 && m_physic.get_velocity_x() + m_wind_velocity.x < end_speed.x)
+    end_velocity.x = std::min(vec_acceleration.x, adjusted_end_speed.x);
+  if (adjusted_end_speed.x < 0 && m_physic.get_velocity_x() + m_wind_velocity.x > end_speed.x)
+    end_velocity.x = std::max(vec_acceleration.x, adjusted_end_speed.x);
+  if (adjusted_end_speed.y > 0 && m_physic.get_velocity_y() + m_wind_velocity.y < end_speed.y)
+    end_velocity.y = std::min(vec_acceleration.y, adjusted_end_speed.y);
+  if (adjusted_end_speed.y < 0 && m_physic.get_velocity_y() + m_wind_velocity.y > end_speed.y)
+    end_velocity.y = std::max(vec_acceleration.y, adjusted_end_speed.y);
+
+  m_wind_velocity = glm::lerp(m_wind_velocity, end_velocity, 0.5f);
 }
 
 

src/badguy/badguy.hpp

@@ -63,6 +63,10 @@ class BadGuy : public MovingSprite,
       state and calls active_update and inactive_update */
   virtual void update(float dt_sec) override;
 
+  /** Called each frame during active_update. Applies velocity from
+   *  wind if the badguy is inside wind and resets it if not. */
+  virtual void handle_wind();
+
   static std::string class_name() { return "badguy"; }
   virtual std::string get_class_name() const override { return class_name(); }
   virtual std::string get_exposed_class_name() const override { return "BadGuy"; }
@@ -154,8 +158,8 @@ class BadGuy : public MovingSprite,
   /** Returns true if the badguy can currently be affected by wind */
   virtual bool can_be_affected_by_wind() const;
 
-  /** Adds velocity from wind */
-  virtual void add_wind_velocity(const Vector& velocity, const Vector& end_speed);
+  /** Version of `add_velocity` with modifications for wind physics */
+  void add_wind_velocity(const float acceleration, const Vector& end_speed, const float dt_sec);
 
   Physic& get_physic() { return m_physic; }
 
@@ -262,6 +266,9 @@ class BadGuy : public MovingSprite,
 protected:
   Physic m_physic;
 
+  Vector m_wind_velocity;
+  float m_wind_acceleration;
+
 public:
   /** Count this badguy to the statistics? This value should not be
       changed during runtime. */

src/badguy/dart.cpp

@@ -96,6 +96,10 @@ void
 Dart::active_update(float dt_sec)
 {
   BadGuy::active_update(dt_sec);
+
+  m_physic.set_velocity_y(m_physic.get_velocity_y() * 0.9f);
+  m_col.set_movement(m_physic.get_movement(dt_sec));
+
   sound_source->set_position(get_pos());
 }
 

src/badguy/fish_harmless.cpp

@@ -26,7 +26,12 @@ void
 FishHarmless::initialize()
 {
   FishSwimming::initialize();
-  set_colgroup_active(COLGROUP_MOVING_ONLY_STATIC);
+  set_colgroup_active(COLGROUP_MOVING);
+}
+
+HitResponse
+FishHarmless::collision_player(Player& player, const CollisionHit& hit) {
+  return HitResponse::ABORT_MOVE;
 }
 
 /* EOF */

src/badguy/fish_harmless.hpp

@@ -36,6 +36,7 @@ class FishHarmless final : public FishSwimming
 
 protected:
   virtual void initialize() override;
+  virtual HitResponse collision_player(Player& player, const CollisionHit& hit) override;
 
 private:
   FishHarmless(const FishHarmless&) = delete;

src/badguy/flyingsnowball.cpp

@@ -32,6 +32,7 @@ const float GLOBAL_SPEED_MULT = 0.8f; /**< The overall movement speed/rate. */
 FlyingSnowBall::FlyingSnowBall(const ReaderMapping& reader) :
   BadGuy(reader, "images/creatures/flying_snowball/flying_snowball.sprite"),
   total_time_elapsed(),
+  prev_height(0.f),
   puff_timer()
 {
   m_physic.enable_gravity(false);
@@ -75,16 +76,24 @@ FlyingSnowBall::active_update(float dt_sec)
 
   float delta = total_time_elapsed * GLOBAL_SPEED_MULT;
 
-  // Put that function in a graphing calculator :
+  // Derivative of the following function (put it in a graphing calculator):
   // sin(x)^3 + sin(3(x - pi/3))/3
-  float targetHgt = std::pow(std::sin(delta), 3.f) +
-                    std::sin(3.f *
-                             ((delta - math::PI) / 3.f)
-                            ) / 3.f;
-  targetHgt = targetHgt * 100.f + m_start_position.y;
-  m_physic.set_velocity_y(targetHgt - get_pos().y);
-
-  m_col.set_movement(m_physic.get_movement(1.f));
+  float targetHgt = (
+    std::cos(3.f * (delta - math::PI/3.f))
+    + std::pow(std::sin(delta), 2.f)
+    * std::cos(delta) * 3.f
+  );
+
+  // Simple damping and then movement
+  m_physic.set_velocity_y(m_physic.get_velocity_y() * pow(0.5f, dt_sec));
+  m_physic.set_velocity_y(m_physic.get_velocity_y() + targetHgt);
+
+  m_physic.set_velocity_x(m_physic.get_velocity_x() * pow(0.5f, dt_sec));
+
+  BadGuy::handle_wind();
+
+  m_col.set_movement(m_physic.get_movement(dt_sec));
+
 
   auto player = get_nearest_player();
   if (player) {

src/badguy/flyingsnowball.hpp

@@ -41,6 +41,7 @@ class FlyingSnowBall final : public BadGuy
 
 private:
   float total_time_elapsed;
+  float prev_height;
   Timer puff_timer; /**< time until the next smoke puff is spawned */
 
 private:

src/badguy/kamikazesnowball.cpp

@@ -17,6 +17,7 @@
 #include "badguy/kamikazesnowball.hpp"
 
 #include "audio/sound_manager.hpp"
+#include "supertux/direction.hpp"
 
 namespace{
   static const float KAMIKAZE_SPEED = 200;
@@ -39,6 +40,14 @@ KamikazeSnowball::initialize()
   set_action(m_dir);
 }
 
+void
+KamikazeSnowball::active_update(float dt_sec) {
+  m_physic.set_velocity_y(m_physic.get_velocity_y() * 0.9f);
+  m_col.set_movement(m_physic.get_movement(dt_sec));
+
+  BadGuy::active_update(dt_sec);
+}
+
 bool
 KamikazeSnowball::collision_squished(GameObject& object)
 {

src/badguy/kamikazesnowball.hpp

@@ -29,6 +29,7 @@ class KamikazeSnowball : public BadGuy
 
   virtual void initialize() override;
   virtual void collision_solid(const CollisionHit& hit) override;
+  virtual void active_update(float dt_sec) override;
   static std::string class_name() { return "kamikazesnowball"; }
   virtual std::string get_class_name() const override { return class_name(); }
   static std::string display_name() { return _("Kamikaze Snowball"); }

src/badguy/owl.cpp

@@ -102,6 +102,8 @@ Owl::is_above_player() const
 void
 Owl::active_update (float dt_sec)
 {
+  m_physic.set_velocity_y(m_physic.get_velocity_y() * 0.9f);
+
   BadGuy::active_update (dt_sec);
 
   if (m_frozen)

src/badguy/stalactite.cpp

@@ -74,6 +74,7 @@ Stalactite::active_update(float dt_sec)
       set_colgroup_active(COLGROUP_MOVING);
     }
   } else if (state == STALACTITE_FALLING) {
+    BadGuy::handle_wind();
     m_col.set_movement(m_physic.get_movement(dt_sec));
   }
 

src/badguy/zeekling.cpp

@@ -184,6 +184,12 @@ Zeekling::active_update(float dt_sec) {
     BadGuy::active_update(dt_sec);
     return;
   } else if (state == DIVING) {
+    // Something took away our diving velocity so we should go back up.
+    if (m_physic.get_velocity_y() <= 0.0f) {
+      state = CLIMBING;
+      m_physic.set_velocity_y(-2*fabsf(m_physic.get_velocity_x()));
+      set_action(m_dir);
+    }
     BadGuy::active_update(dt_sec);
     return;
   } else if (state == CLIMBING) {

src/collision/collision_object.cpp

@@ -19,11 +19,13 @@
 
 #include "collision/collision_listener.hpp"
 #include "collision/collision_movement_manager.hpp"
+#include "object/wind.hpp"
 #include "supertux/game_object.hpp"
 
 CollisionObject::CollisionObject(CollisionGroup group, CollisionListener& listener) :
   m_listener(listener),
   m_bbox(),
+  m_colliding_wind(),
   m_group(group),
   m_movement(0.0f, 0.0f),
   m_dest(),
@@ -49,6 +51,9 @@ CollisionObject::collides(CollisionObject& other, const CollisionHit& hit) const
 HitResponse
 CollisionObject::collision(CollisionObject& other, const CollisionHit& hit)
 {
+  if(dynamic_cast<Wind*>(&other.m_listener)) {
+    collide_wind(other);
+  }
   return m_listener.collision(dynamic_cast<GameObject&>(other.m_listener), hit);
 }
 
@@ -72,6 +77,17 @@ void
 CollisionObject::notify_object_removal(CollisionObject* other)
 {
   m_objects_hit_bottom.erase(other);
+  m_colliding_wind.erase(other);
+}
+
+void
+CollisionObject::collide_wind(CollisionObject& other) {
+  m_colliding_wind.insert(&other);
+}
+
+void
+CollisionObject::clear_wind_collision_list() {
+  m_colliding_wind.clear();
 }
 
 void

src/collision/collision_object.hpp

@@ -61,6 +61,10 @@ class CollisionObject
     m_ground_movement_manager = movement_manager;
   }
 
+  void collide_wind(CollisionObject& other);
+
+  void clear_wind_collision_list();
+
   void clear_bottom_collision_list();
 
   bool is_unisolid() const { return m_unisolid; }
@@ -149,6 +153,9 @@ class CollisionObject
       this isn't necessarily the bounding box for graphics) */
   Rectf m_bbox;
 
+  /** All wind areas that the player is currently touching */
+  std::unordered_set<CollisionObject*> m_colliding_wind;
+
   /** The collision group */
   CollisionGroup m_group;
 

src/collision/collision_system.cpp

@@ -590,6 +590,7 @@ CollisionSystem::update()
     object->m_pressure = Vector(0, 0);
     object->m_dest.move(object->get_movement());
     object->clear_bottom_collision_list();
+    object->clear_wind_collision_list();
   }
 
   // Part 1: COLGROUP_MOVING vs COLGROUP_STATIC and tilemap.