Merge pull request #879 from lethal-guitar/improve-parity

Improve parity

Author: lethal-guitar

src/engine/map_renderer.cpp

@@ -177,7 +177,8 @@ base::Vec2f backdropOffset(
     else
     {
       return {
-        0.0f, float(GameTraits::viewportHeightPx) - backdropAutoScrollOffset};
+        cameraPosition.x * PARALLAX_FACTOR,
+        float(GameTraits::viewportHeightPx) - backdropAutoScrollOffset};
     }
   }
 

src/game_logic/damage_infliction_system.cpp

@@ -65,22 +65,23 @@ DamageInflictionSystem::DamageInflictionSystem(
 
 void DamageInflictionSystem::update(ex::EntityManager& es)
 {
-  es.each<DamageInflicting, WorldPosition, BoundingBox>(
+  es.each<Shootable, WorldPosition, BoundingBox>(
     [this, &es](
-      ex::Entity inflictorEntity,
-      DamageInflicting& damage,
-      const WorldPosition& inflictorPosition,
-      const BoundingBox& bbox) {
-      const auto inflictorBbox = engine::toWorldSpace(bbox, inflictorPosition);
-
-      ex::ComponentHandle<Shootable> shootable;
-      ex::ComponentHandle<WorldPosition> shootablePos;
-      ex::ComponentHandle<BoundingBox> shootableBboxLocal;
-      for (auto shootableEntity : es.entities_with_components(
-             shootable, shootablePos, shootableBboxLocal))
+      ex::Entity shootableEntity,
+      Shootable& shootable,
+      const WorldPosition& shootablePos,
+      const BoundingBox& shootableBboxLocal) {
+      const auto shootableBbox =
+        engine::toWorldSpace(shootableBboxLocal, shootablePos);
+
+      ex::ComponentHandle<DamageInflicting> damage;
+      ex::ComponentHandle<WorldPosition> inflictorPosition;
+      ex::ComponentHandle<BoundingBox> inflictorBboxLocal;
+      for (auto inflictorEntity : es.entities_with_components(
+             damage, inflictorPosition, inflictorBboxLocal))
       {
-        const auto shootableBbox =
-          engine::toWorldSpace(*shootableBboxLocal, *shootablePos);
+        const auto inflictorBbox =
+          engine::toWorldSpace(*inflictorBboxLocal, *inflictorPosition);
 
         const auto shootableOnScreen =
           shootableEntity.has_component<Active>() &&
@@ -89,17 +90,12 @@ void DamageInflictionSystem::update(ex::EntityManager& es)
         // clang-format off
         if (
           shootableBbox.intersects(inflictorBbox) &&
-          !shootable->mInvincible &&
-          (shootableOnScreen || shootable->mCanBeHitWhenOffscreen))
+          !shootable.mInvincible &&
+          (shootableOnScreen || shootable.mCanBeHitWhenOffscreen))
         // clang-format on
         {
-          const auto destroyOnContact =
-            damage.mDestroyOnContact || shootable->mAlwaysConsumeInflictor;
-          inflictDamage(inflictorEntity, damage, shootableEntity, *shootable);
-          if (destroyOnContact)
-          {
-            break;
-          }
+          inflictDamage(inflictorEntity, *damage, shootableEntity, shootable);
+          break;
         }
       }
     });

src/game_logic/game_world.cpp

@@ -422,6 +422,13 @@ void GameWorld::receive(const rigel::events::ExitReached& event)
 }
 
 
+void GameWorld::receive(const rigel::events::HintMachineMessage& event)
+{
+  mMessageDisplay.setMessage(
+    event.mText, ui::MessagePriority::HintMachineMessage);
+}
+
+
 void GameWorld::receive(const rigel::events::PlayerDied& event)
 {
   mpState->mPlayerDied = true;
@@ -566,6 +573,7 @@ void GameWorld::subscribe(entityx::EventManager& eventManager)
 {
   eventManager.subscribe<rigel::events::CheckPointActivated>(*this);
   eventManager.subscribe<rigel::events::ExitReached>(*this);
+  eventManager.subscribe<rigel::events::HintMachineMessage>(*this);
   eventManager.subscribe<rigel::events::PlayerDied>(*this);
   eventManager.subscribe<rigel::events::PlayerTookDamage>(*this);
   eventManager.subscribe<rigel::events::PlayerMessage>(*this);
@@ -585,6 +593,7 @@ void GameWorld::unsubscribe(entityx::EventManager& eventManager)
 {
   eventManager.unsubscribe<rigel::events::CheckPointActivated>(*this);
   eventManager.unsubscribe<rigel::events::ExitReached>(*this);
+  eventManager.unsubscribe<rigel::events::HintMachineMessage>(*this);
   eventManager.unsubscribe<rigel::events::PlayerDied>(*this);
   eventManager.unsubscribe<rigel::events::PlayerTookDamage>(*this);
   eventManager.unsubscribe<rigel::events::PlayerMessage>(*this);
@@ -1159,7 +1168,7 @@ void GameWorld::quickSave()
   mpQuickSave = std::make_unique<QuickSaveData>(
     QuickSaveData{*mpPlayerModel, std::move(pStateCopy)});
 
-  mMessageDisplay.setMessage("Quick saved.");
+  mMessageDisplay.setMessage("Quick saved.", ui::MessagePriority::Menu);
 
   LOG_F(INFO, "Quick save created");
 }
@@ -1178,7 +1187,7 @@ void GameWorld::quickLoad()
   mpState->synchronizeTo(
     *mpQuickSave->mpState, mpServiceProvider, mpPlayerModel, mSessionId);
   mpState->mPreviousCameraPosition = mpState->mCamera.position();
-  mMessageDisplay.setMessage("Quick save restored.");
+  mMessageDisplay.setMessage("Quick save restored.", ui::MessagePriority::Menu);
 
   if (!mpOptions->mMotionSmoothing)
   {

src/game_logic/game_world.hpp

@@ -88,6 +88,7 @@ class GameWorld : public entityx::Receiver<GameWorld>
 
   void receive(const rigel::events::CheckPointActivated& event);
   void receive(const rigel::events::ExitReached& event);
+  void receive(const rigel::events::HintMachineMessage& event);
   void receive(const rigel::events::PlayerDied& event);
   void receive(const rigel::events::PlayerTookDamage& event);
   void receive(const rigel::events::PlayerMessage& event);

src/game_logic/global_dependencies.hpp

@@ -144,6 +144,12 @@ struct PlayerMessage
 };
 
 
+struct HintMachineMessage
+{
+  std::string mText;
+};
+
+
 struct TutorialMessage
 {
   TutorialMessage() = default;

src/game_logic/player.cpp

@@ -1126,7 +1126,7 @@ void Player::updateMovement(
           startFallingDelayed();
         }
       }
-      else if (movementVector.x != 0)
+      else if (movementVector.x != 0 && !fireButton.mIsPressed)
       {
         if (movementVector.x != orientationAsMovement)
         {

src/game_logic/player/interaction_system.cpp

@@ -488,7 +488,7 @@ void PlayerInteractionSystem::activateHintMachine(entityx::Entity entity)
     mLevelHints.getHint(mSessionId.mEpisode, mSessionId.mLevel);
   if (maybeHint)
   {
-    showMessage(*maybeHint);
+    mpEvents->emit(rigel::events::HintMachineMessage{*maybeHint});
   }
 
   entity.remove<Interactable>();

src/ui/ingame_message_display.cpp

@@ -44,11 +44,16 @@ IngameMessageDisplay::IngameMessageDisplay(
 }
 
 
-void IngameMessageDisplay::setMessage(std::string message)
+void IngameMessageDisplay::setMessage(
+  std::string message,
+  MessagePriority priority)
 {
-  if (!message.empty())
+  if (
+    !message.empty() &&
+    (priority >= mCurrentPriority || !std::holds_alternative<Printing>(mState)))
   {
     mMessage = std::move(message);
+    mCurrentPriority = priority;
     mPrintedMessage.clear();
     mState = Printing{};
   }

src/ui/ingame_message_display.hpp

@@ -32,14 +32,24 @@ class MenuElementRenderer;
 namespace rigel::ui
 {
 
+enum class MessagePriority
+{
+  Normal,
+  HintMachineMessage,
+  Menu
+};
+
+
 class IngameMessageDisplay
 {
 public:
   IngameMessageDisplay(
     IGameServiceProvider* pServiceProvider,
     MenuElementRenderer* pTextRenderer);
 
-  void setMessage(std::string message);
+  void setMessage(
+    std::string message,
+    MessagePriority priority = MessagePriority::Normal);
 
   void update();
   void render();
@@ -87,6 +97,7 @@ class IngameMessageDisplay
   std::string mMessage;
   // TODO: Use a string_view instead of a second string once upgraded to C++ 17
   std::string mPrintedMessage;
+  MessagePriority mCurrentPriority = MessagePriority::Normal;
 
   MenuElementRenderer* mpTextRenderer;
   IGameServiceProvider* mpServiceProvider;