Merge pull request #518 from lethal-guitar/fix-item-boxes

Make item container release sequence match the original

Author: lethal-guitar

src/game_logic/entity_configuration.ipp

@@ -67,19 +67,6 @@ const int FLY_ANIMATION_SEQUENCE[] = { 0, 1, 2, 1 };
 const int BOSS4_PROJECTILE_SPAWN_ANIM_SEQ[] = { 0, 1, 1, 2, 2, 3, 3, 4 };
 
 
-const base::Point<float> CONTAINER_BOUNCE_SEQUENCE[] = {
-  {0.0f, -3.0f},
-  {0.0f, -2.0f},
-  {0.0f, -1.0f},
-  {0.0f, 0.0f},
-  {0.0f, 1.0f},
-  {0.0f, 2.0f},
-  {0.0f, 3.0f},
-  {0.0f, -1.0f},
-  {0.0f, 1.0f}
-};
-
-
 #include "destruction_effect_specs.ipp"
 
 
@@ -759,11 +746,9 @@ void EntityFactory::configureItemBox(
   addToContainer(
     container,
     Active{},
-    MovementSequence{
-      CONTAINER_BOUNCE_SEQUENCE, ResetAfterSequence{true}, EnableX{false}});
-  addDefaultMovingBody(
-    container,
-    engine::inferBoundingBox(*entity.component<Sprite>(), entity));
+    MovingBody{Velocity{0.0f, 0.0f}, GravityAffected{false}},
+    engine::inferBoundingBox(*entity.component<Sprite>(), entity),
+    ActivationSettings{ActivationSettings::Policy::Always});
 
   auto containerSprite = createSpriteForId(actorIdForBoxColor(color));
   turnIntoContainer(entity, containerSprite, givenScore, std::move(container));
@@ -1072,7 +1057,7 @@ void EntityFactory::configureEntity(
           std::move(livingTurkeyContainer));
         entity.assign<DestructionEffects>(CONTAINER_BOX_KILL_EFFECT_SPEC);
         entity.component<ItemContainer>()->mStyle =
-          ItemContainer::ReleaseStyle::ItemBox;
+          ItemContainer::ReleaseStyle::ItemBoxNoBounce;
         entity.assign<AppearsOnRadar>();
       }
       break;
@@ -1993,6 +1978,7 @@ void EntityFactory::configureEntity(
           PlayerDamaging{Damage{1}},
           AnimationLoop{1},
           AutoDestroy::afterTimeout(numAnimationFrames),
+          ActivationSettings{ActivationSettings::Policy::Always},
           Active{});
         container.mStyle = ItemContainer::ReleaseStyle::NuclearWasteBarrel;
 

src/game_logic/ingame_systems.cpp

@@ -115,7 +115,7 @@ IngameSystems::IngameSystems(
       pEntityFactory,
       &mParticles,
       eventManager)
-  , mItemContainerSystem(&entities, eventManager)
+  , mItemContainerSystem(&entities, &mCollisionChecker, eventManager)
   , mBlueGuardSystem(
       &mPlayer,
       &mCollisionChecker,
@@ -230,6 +230,7 @@ void IngameSystems::update(
   // Physics and other updates
   // ----------------------------------------------------------------------
   mPhysicsSystem.updatePhase1(es);
+  mItemContainerSystem.updateItemBounce(es);
 
   // Collect items after physics, so that any collectible
   // items are in their final positions for this frame.

src/game_logic/interactive/item_container.cpp

@@ -32,18 +32,38 @@
 
 namespace rigel::game_logic {
 
+namespace {
+
 using engine::components::Active;
 using engine::components::BoundingBox;
+using engine::components::MovingBody;
 using engine::components::Sprite;
 using engine::components::WorldPosition;
 using game_logic::components::ItemContainer;
 
+constexpr int ITEM_BOUNCE_SEQUENCE[] = {-3, -2, -1, 0, 1, 2, 3, -1, 1};
+
+
+struct ItemBounceEffect {
+  explicit ItemBounceEffect(const float fallVelocity)
+    : mFallVelocity(fallVelocity)
+  {
+  }
+
+  int mFramesElapsed = 1;
+  float mFallVelocity = 0.0f;
+};
+
+}
+
 
 ItemContainerSystem::ItemContainerSystem(
   entityx::EntityManager* pEntityManager,
+  const engine::CollisionChecker* pCollisionChecker,
   entityx::EventManager& events
 )
   : mpEntityManager(pEntityManager)
+  , mpCollisionChecker(pCollisionChecker)
 {
   events.subscribe<events::ShootableKilled>(*this);
 }
@@ -62,8 +82,7 @@ void ItemContainerSystem::update(entityx::EntityManager& es) {
     }
 
     contents.assign<WorldPosition>(*entity.component<WorldPosition>());
-
-    entity.destroy();
+    return contents;
   };
 
   for (auto& entity : mShotContainersQueue) {
@@ -72,15 +91,26 @@ void ItemContainerSystem::update(entityx::EntityManager& es) {
     switch (container.mStyle) {
       case RS::Default:
         releaseItem(entity, container.mContainedComponents);
+        entity.destroy();
         break;
 
       case RS::ItemBox:
+      case RS::ItemBoxNoBounce:
         ++container.mFramesElapsed;
 
         if (container.mFramesElapsed == 1) {
           entity.component<Sprite>()->flashWhite();
         } else if (container.mFramesElapsed == 2) {
-          releaseItem(entity, container.mContainedComponents);
+          auto item = releaseItem(entity, container.mContainedComponents);
+
+          if (container.mStyle != RS::ItemBoxNoBounce) {
+            const auto fallVelocity =
+              entity.component<MovingBody>()->mVelocity.y;
+            item.assign<ItemBounceEffect>(fallVelocity);
+            item.component<WorldPosition>()->y += ITEM_BOUNCE_SEQUENCE[0];
+          }
+
+          entity.destroy();
         }
         break;
 
@@ -97,6 +127,7 @@ void ItemContainerSystem::update(entityx::EntityManager& es) {
           entity.component<Sprite>()->mShow = false;
         } else if (container.mFramesElapsed == 4) {
           releaseItem(entity, container.mContainedComponents);
+          entity.destroy();
         }
         break;
     }
@@ -111,6 +142,35 @@ void ItemContainerSystem::update(entityx::EntityManager& es) {
 }
 
 
+void ItemContainerSystem::updateItemBounce(entityx::EntityManager& es) {
+  es.each<WorldPosition, BoundingBox, MovingBody, ItemBounceEffect>(
+    [this](
+      entityx::Entity entity,
+      WorldPosition& position,
+      const BoundingBox& bbox,
+      MovingBody& body,
+      ItemBounceEffect& state
+    ) {
+      position.y += ITEM_BOUNCE_SEQUENCE[state.mFramesElapsed];
+
+      const auto hasLanded =
+        mpCollisionChecker->isOnSolidGround(position, bbox);
+      if (
+        (state.mFramesElapsed == 7 && !hasLanded) ||
+        state.mFramesElapsed == 9
+      ) {
+        body.mGravityAffected = true;
+        body.mVelocity.y = state.mFallVelocity;
+      }
+
+      ++state.mFramesElapsed;
+      if (state.mFramesElapsed == 9) {
+        entity.remove<ItemBounceEffect>();
+      }
+    });
+}
+
+
 void ItemContainerSystem::receive(const events::ShootableKilled& event) {
   auto entity = event.mEntity;
   if (entity.has_component<ItemContainer>()) {
@@ -194,7 +254,7 @@ void NapalmBomb::explode(GlobalDependencies& d, entityx::Entity entity) {
   mState = NapalmBomb::State::SpawningFires;
   mFramesElapsed = 0;
   entity.component<Sprite>()->mShow = false;
-  entity.remove<engine::components::MovingBody>();
+  entity.remove<MovingBody>();
   entity.remove<game_logic::components::AppearsOnRadar>();
 
   // Once the bomb explodes, it counts towards bonus 6. This means we need to

src/game_logic/interactive/item_container.hpp

@@ -83,6 +83,7 @@ struct ItemContainer {
   enum class ReleaseStyle : std::uint8_t {
     Default,
     ItemBox,
+    ItemBoxNoBounce,
     NuclearWasteBarrel
   };
 
@@ -103,13 +104,16 @@ class ItemContainerSystem : public entityx::Receiver<ItemContainerSystem> {
 public:
   ItemContainerSystem(
     entityx::EntityManager* pEntityManager,
+    const engine::CollisionChecker* pCollisionChecker,
     entityx::EventManager& events);
 
   void update(entityx::EntityManager& es);
+  void updateItemBounce(entityx::EntityManager& es);
   void receive(const events::ShootableKilled& event);
 
 private:
   entityx::EntityManager* mpEntityManager;
+  const engine::CollisionChecker* mpCollisionChecker;
   std::vector<entityx::Entity> mShotContainersQueue;
 };