Zeekling behaviour improvements

src/badguy/zeekling.cpp

@@ -19,14 +19,18 @@
 
 #include <math.h>
 
+#include "math/easing.hpp"
 #include "math/random.hpp"
+#include "math/vector.hpp"
 #include "object/player.hpp"
 #include "sprite/sprite.hpp"
+#include "supertux/sector.hpp"
 
 Zeekling::Zeekling(const ReaderMapping& reader) :
   BadGuy(reader, "images/creatures/zeekling/zeekling.sprite"),
   speed(gameRandom.randf(130.0f, 171.0f)),
-  diveRecoverTimer(),
+  m_easing_progress(0.0),
+  m_swoop_up_timer(),
   state(FLYING),
   last_player(nullptr),
   last_player_pos(0.0f, 0.0f),
@@ -54,149 +58,132 @@ Zeekling::collision_squished(GameObject& object)
 }
 
 void
-Zeekling::onBumpHorizontal()
+Zeekling::on_bump_horizontal()
 {
-  if (state == FLYING) {
-    m_dir = (m_dir == Direction::LEFT ? Direction::RIGHT : Direction::LEFT);
-    set_action(m_dir);
-    m_physic.set_velocity_x(m_dir == Direction::LEFT ? -speed : speed);
-  } else
-    if (state == DIVING) {
-      m_dir = (m_dir == Direction::LEFT ? Direction::RIGHT : Direction::LEFT);
-      state = FLYING;
-      set_action(m_dir);
-      m_physic.set_velocity(m_dir == Direction::LEFT ? -speed : speed, 0);
-    } else
-      if (state == CLIMBING) {
-        m_dir = (m_dir == Direction::LEFT ? Direction::RIGHT : Direction::LEFT);
-        set_action(m_dir);
-        m_physic.set_velocity_x(m_dir == Direction::LEFT ? -speed : speed);
-      } else {
-        assert(false);
-      }
+  m_dir = (m_dir == Direction::LEFT ? Direction::RIGHT : Direction::LEFT);
+  set_action(m_dir);
+  m_physic.set_velocity_x(m_dir == Direction::LEFT ? -speed : speed);
+
+  if (state == DIVING)
+  {
+    state = FLYING;
+    m_physic.set_velocity_y(0);
+  }
 }
 
 void
-Zeekling::onBumpVertical()
+Zeekling::on_bump_vertical()
 {
   if (BadGuy::get_state() == STATE_BURNING)
   {
     m_physic.set_velocity(0, 0);
     return;
   }
-  if (state == FLYING) {
-    m_physic.set_velocity_y(0);
-  } else
-    if (state == DIVING) {
+
+  switch (state) {
+    case DIVING:
       state = CLIMBING;
-      m_physic.set_velocity_y(-speed);
       set_action(m_dir);
-    } else
-      if (state == CLIMBING) {
-        state = FLYING;
-        m_physic.set_velocity_y(0);
-      }
+      break;
+
+    case CLIMBING:
+      state = FLYING;
+      break;
+
+    default:
+      break;
+  }
+
+    m_physic.set_velocity_y(state == CLIMBING ? -speed : 0);
 }
 
 void
 Zeekling::collision_solid(const CollisionHit& hit)
 {
   if (m_frozen)
-    BadGuy::collision_solid(hit);
-  else
   {
-    if (m_sprite->get_action() == "squished-left" ||
+    BadGuy::collision_solid(hit);
+    return;
+  }
+
+  if (m_sprite->get_action() == "squished-left" ||
       m_sprite->get_action() == "squished-right")
-    {
-      return;
-    }
-
-    if (hit.top || hit.bottom) {
-      onBumpVertical();
-    }
-    else if (hit.left || hit.right) {
-      onBumpHorizontal();
-    }
+  {
+    return;
+  }
+
+  if (hit.top || hit.bottom) {
+    on_bump_vertical();
+  }
+  else if (hit.left || hit.right)
+  {
+    on_bump_horizontal();
   }
 }
 
-/** Linear prediction of player and badguy positions to decide if we should enter the DIVING state. */
 bool
 Zeekling::should_we_dive()
 {
-  if (m_frozen)
-    return false;
+  if (m_frozen) return false;
 
-  const auto player = get_nearest_player();
-  if (player && last_player && (player == last_player)) {
+  // Left/rightmost point of the hitbox.
+  Vector eye;
+  const Rectf& bbox = get_bbox().grown(1.f);
+  eye = bbox.get_middle();
+  eye.x = m_dir == Direction::LEFT ? bbox.get_left() : bbox.get_right();
 
-    // Get positions and calculate movement.
-    const Vector& player_pos = player->get_pos();
-    const Vector player_mov = (player_pos - last_player_pos);
-    const Vector self_pos = m_col.m_bbox.p1();
-    const Vector self_mov = (self_pos - last_self_pos);
+  const Vector& plrmid = get_nearest_player()->get_bbox().get_middle();
 
-    // New vertical speed to test with.
-    float vy = 2*fabsf(self_mov.x);
+  // Do not dive if we are not above the player.
+  float height = plrmid.y - eye.y;
+  if (height <= 0) return false;
 
-    // Do not dive if we are not above the player.
-    float height = player_pos.y - self_pos.y;
-    if (height <= 0) return false;
+  // Do not dive if we are too far above the player.
+  if (height > 512) return false;
 
-    // Do not dive if we are too far above the player.
-    if (height > 512) return false;
+  const Vector& rangeend = {eye.x + ((plrmid.y - eye.y) *
+                                     (m_dir == Direction::LEFT ? -1 : 1)),
+                            plrmid.y};
 
-    // Do not dive if we would not descend faster than the player.
-    float relSpeed = vy - player_mov.y;
-    if (relSpeed <= 0) return false;
+  // FIXME: Give the actual object that hit the raycast, or at least the hitbox
+  // to avoid having to raycast a bunch of times
+  return !Sector::get().free_line_of_sight(eye, rangeend, false, this) &&
+          Sector::get().can_see_player(eye);
+}
 
-    // Guess number of frames to descend to same height as player.
-    float estFrames = height / relSpeed;
+void
+Zeekling::active_update(float dt_sec) {
+  switch (state) {
+    case FLYING:
+      if (state != DIVING && should_we_dive())
+      {
+        // swoop a bit up
+        state = DIVING;
+        m_physic.set_velocity_y(2 * -(fabsf(m_physic.get_velocity_x())));
+        m_swoop_up_timer.start(0.2f);
+        set_action("charge", m_dir);
+      }
 
-    // Guess where the player would be at this time.
-    float estPx = (player_pos.x + (estFrames * player_mov.x));
+      break;
 
-    // Guess where we would be at this time.
-    float estBx = (self_pos.x + (estFrames * self_mov.x));
+    case DIVING:
+      if (!m_swoop_up_timer.check()) break;
 
-    // Allow for slight inaccuracies.
-    if (fabsf(estPx - estBx) < 8) return true;
-  }
+      // swoop down
+      set_action("dive", m_dir);
+      m_physic.set_velocity_y(2 * fabsf(m_physic.get_velocity_x()));
+      break;
 
-  // Update the last player tracked, as well as our positions.
-  last_player = player;
-  if (player) {
-    last_player_pos = player->get_pos();
-    last_self_pos = m_col.m_bbox.p1();
+    case CLIMBING:
+      // Stop climbing when we're back at initial height.
+      if (get_pos().y <= m_start_position.y) {
+        state = FLYING;
+        m_physic.set_velocity_y(0);
+      }
+      break;
   }
 
-  return false;
-}
-
-void
-Zeekling::active_update(float dt_sec) {
-  if (state == FLYING) {
-    if (should_we_dive()) {
-      state = DIVING;
-      m_physic.set_velocity_y(2*fabsf(m_physic.get_velocity_x()));
-      set_action("dive", m_dir);
-    }
     BadGuy::active_update(dt_sec);
-    return;
-  } else if (state == DIVING) {
-    BadGuy::active_update(dt_sec);
-    return;
-  } else if (state == CLIMBING) {
-    // Stop climbing when we're back at initial height.
-    if (get_pos().y <= m_start_position.y) {
-      state = FLYING;
-      m_physic.set_velocity_y(0);
-    }
-    BadGuy::active_update(dt_sec);
-    return;
-  } else {
-    assert(false);
-  }
 }
 
 void

src/badguy/zeekling.hpp

@@ -44,8 +44,8 @@ class Zeekling final : public BadGuy
   virtual bool collision_squished(GameObject& object) override;
 
   bool should_we_dive();
-  void onBumpHorizontal();
-  void onBumpVertical();
+  void on_bump_horizontal();
+  void on_bump_vertical();
 
 private:
   enum ZeeklingState {
@@ -56,7 +56,8 @@ class Zeekling final : public BadGuy
 
 private:
   float speed;
-  Timer diveRecoverTimer;
+  double m_easing_progress;
+  Timer m_swoop_up_timer;
   ZeeklingState state;
   const MovingObject* last_player; /**< Last player we tracked. */
   Vector last_player_pos; /**< Position we last spotted the player at. */