Wind and swimming updates

src/badguy/badguy.cpp

@@ -386,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)
@@ -407,6 +409,20 @@ BadGuy::active_update(float dt_sec)
   }
 }
 
+void
+BadGuy::handle_wind()
+{
+  if (!m_col.m_colliding_wind.empty())
+  {
+    if (on_ground() && m_physic.get_wind_velocity_y() > 0.f)
+      m_physic.set_wind_velocity_y(0.f);
+  }
+  else {
+    m_physic.set_wind_velocity(Vector(0.f));
+    m_physic.set_wind_acceleration(0.0);
+  }
+}
+
 void
 BadGuy::inactive_update(float )
 {
@@ -1189,24 +1205,9 @@ BadGuy::after_editor_set()
 bool
 BadGuy::can_be_affected_by_wind() const
 {
-  return !on_ground();
-}
-
-void
-BadGuy::add_wind_velocity(const Vector& velocity, const Vector& end_speed)
-{
-  // 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));
+  return true;
 }
 
-
 void
 BadGuy::register_class(ssq::VM& vm)
 {

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,9 +158,6 @@ 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);
-
   inline Physic& get_physic() { return m_physic; }
 
 protected:

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

@@ -75,16 +75,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/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(MovingObject& 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

@@ -234,6 +234,7 @@ Zeekling::active_update(float dt_sec) {
         break;
       }
 
+
       const float dist = m_target_y - m_start_position.y;
       const double progress = CubicEaseIn(static_cast<double>(1.f - m_timer.get_progress()));
       const float value = m_target_y - (static_cast<float>(progress) * dist);

src/collision/collision_object.cpp

@@ -18,11 +18,13 @@
 #include "collision/collision_object.hpp"
 
 #include "collision/collision_movement_manager.hpp"
+#include "object/wind.hpp"
 #include "supertux/moving_object.hpp"
 
 CollisionObject::CollisionObject(CollisionGroup group, MovingObject& parent) :
   m_parent(parent),
   m_bbox(),
+  m_colliding_wind(),
   m_group(group),
   m_movement(0.0f, 0.0f),
   m_dest(),
@@ -48,6 +50,9 @@ CollisionObject::collides(CollisionObject& other, const CollisionHit& hit) const
 HitResponse
 CollisionObject::collision(CollisionObject& other, const CollisionHit& hit)
 {
+  if(dynamic_cast<Wind*>(&other.m_parent)) {
+    collide_wind(other);
+  }
   return m_parent.collision(other.m_parent, hit);
 }
 
@@ -71,6 +76,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

@@ -60,6 +60,10 @@ class CollisionObject
     m_ground_movement_manager = movement_manager;
   }
 
+  void collide_wind(CollisionObject& other);
+
+  void clear_wind_collision_list();
+
   void clear_bottom_collision_list();
 
   inline bool is_unisolid() const { return m_unisolid; }
@@ -145,6 +149,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.

src/math/vector.hpp

@@ -42,6 +42,34 @@ inline Vector at_angle(Vector const& v, float angle)
   return vec2_from_polar(glm::length(v), angle);
 }
 
+// Move vector towards a new vector by a scalar delta.
+inline Vector move_towards(Vector const& from, Vector const& to, float d) {
+  // Based on Godot's implementation
+  Vector vd = to - from;
+  float len = vd.length();
+  return len <= d ? to : from + vd / len * d;
+}
+
+// Change a velocity vector towards another, but do not change a component towards zero unless their signs are opposite.
+inline Vector push_to_velocity(Vector const& from, Vector const& to, float d) {
+  if (d == 0.f) return from;
+  if (from == to) return from;
+
+  Vector diff = glm::normalize(to - from) * d;
+  Vector result = from;
+
+  if (to.x > 0 && from.x < to.x)
+    result.x = std::min(from.x + diff.x, to.x);
+  if (to.x < 0 && from.x > to.x)
+    result.x = std::max(from.x + diff.x, to.x);
+  if (to.y > 0 && from.y < to.y)
+    result.y = std::min(from.y + diff.y, to.y);
+  if (to.y < 0 && from.y > to.y)
+    result.y = std::max(from.y + diff.y, to.y);
+
+  return result;
+}
+
 } // namespace math
 
 #endif