Add class for picking and tracking objects

PickedMovableObject represents a node object figure that has been picked
to be followed in the observation window.

Author: falbrechtskirchinger

libs/s25main/PickedMovableObject.cpp

@@ -0,0 +1,172 @@
+// Copyright (C) 2005 - 2023 Settlers Freaks (sf-team at siedler25.org)
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "PickedMovableObject.h"
+#include "desktops/dskGameInterface.h"
+#include "drivers/VideoDriverWrapper.h"
+#include "world/GameWorldBase.h"
+#include "world/GameWorldView.h"
+#include "nodeObjs/noMovable.h"
+#include <cmath>
+
+namespace {
+constexpr unsigned PickRadius = 2;
+constexpr unsigned TrackRadius = 5;
+constexpr unsigned long ExpireIn = 5000;
+constexpr auto ExpireNever = static_cast<unsigned long>(-1);
+
+// Make (ab-)use of CheckPointsInRadius() easier
+constexpr bool CheckPointsBreak = true;
+constexpr bool CheckPointsContinue = false;
+} // namespace
+
+PickedMovableObject PickedMovableObject::Pick(const GameWorldView& gwv, MapPoint mapPt, DrawPoint drawPt, bool expire)
+{
+    // DEBUG REMOVE BEFORE MERGE
+    unsigned i = 1;
+
+    const auto offset = gwv.GetOffset();
+    const auto center = gwv.GetSize() / 2.f;
+    const auto zoomFactor = gwv.GetZoomFactor();
+    const auto& world = gwv.GetWorld();
+    const auto worldSize = world.GetSize() * DrawPoint(TR_W, TR_H);
+    auto minDistance = std::numeric_limits<float>::max();
+
+    PickedMovableObject pmo;
+
+    world.CheckPointsInRadius(
+      mapPt, PickRadius,
+      [&](MapPoint curPt, unsigned) {
+          if(gwv.GetViewer().GetVisibility(curPt) != Visibility::Visible)
+              return CheckPointsContinue;
+
+          DrawPoint curDrawPt = world.GetNodePos(curPt);
+          if(curDrawPt.x < offset.x)
+              curDrawPt.x += worldSize.x;
+          if(curDrawPt.y < offset.y)
+              curDrawPt.y += worldSize.y;
+          curDrawPt -= offset;
+          for(const noBase& obj : world.GetFigures(curPt))
+          {
+              const auto* movable = dynamic_cast<const noMovable*>(&obj);
+              if(!movable)
+                  continue;
+
+              DrawPoint objDrawPt = curDrawPt;
+              if(movable->IsMoving())
+                  objDrawPt += movable->CalcWalkingRelative();
+              objDrawPt = DrawPoint((objDrawPt - center) * zoomFactor + center);
+
+              // DEBUG REMOVE BEFORE MERGE
+              dskGameInterface::SetDebugPoint(i++, objDrawPt, 8, 4, MakeColor(255, 255, 0, 255));
+
+              auto diff = Point<float>(objDrawPt - drawPt);
+              float distance = std::sqrt(diff.x * diff.x + diff.y * diff.y);
+              if(distance < minDistance)
+              {
+                  pmo.id_ = movable->GetObjId();
+                  pmo.mapPt_ = curPt;
+                  pmo.drawPt_ = objDrawPt; // TODO Do we need the unwrapped point here or was this always wrong?
+                  minDistance = distance;
+              }
+          }
+
+          return CheckPointsContinue;
+      },
+      true);
+
+    if(pmo.IsValid() && expire)
+        pmo.expiration_ = VIDEODRIVER.GetTickCount() + ExpireIn;
+
+    return pmo;
+}
+
+PickedMovableObject PickedMovableObject::PickAtCursor(const GameWorldView& gwv, bool expire)
+{
+    return Pick(gwv, gwv.GetSelectedPt(), DrawPoint(VIDEODRIVER.GetMousePos()), expire);
+}
+
+PickedMovableObject PickedMovableObject::PickAtViewCenter(const GameWorldView& gwv, bool expire)
+{
+    const auto centerMapPt = gwv.GetWorld().MakeMapPoint((gwv.GetFirstPt() + gwv.GetLastPt()) / 2);
+    const auto centerDrawPt = DrawPoint(gwv.GetSize() / 2u);
+    return Pick(gwv, centerMapPt, centerDrawPt, expire);
+}
+
+PickedMovableObject::PickedMovableObject(PickedMovableObject&& other) noexcept
+{
+    *this = std::move(other);
+}
+
+PickedMovableObject& PickedMovableObject::operator=(PickedMovableObject&& other) noexcept
+{
+    id_ = other.id_;
+    mapPt_ = other.mapPt_;
+    drawPt_ = other.drawPt_;
+    expiration_ = other.expiration_;
+
+    // invalidate moved-from object
+    other.Invalidate();
+
+    return *this;
+}
+
+bool PickedMovableObject::IsValid() const
+{
+    return id_ != 0 && VIDEODRIVER.GetTickCount() < expiration_;
+}
+
+void PickedMovableObject::CancelExpiration()
+{
+    expiration_ = ExpireNever;
+}
+
+void PickedMovableObject::Invalidate()
+{
+    id_ = 0;
+    expiration_ = 0;
+}
+
+bool PickedMovableObject::Track(const GameWorldView& gwv)
+{
+    if(!IsValid())
+        return false;
+
+    const auto& world = gwv.GetWorld();
+    const auto success = world.CheckPointsInRadius(
+      mapPt_, TrackRadius,
+      [&](MapPoint curPt, unsigned) {
+          if(gwv.GetViewer().GetVisibility(curPt) != Visibility::Visible)
+              return CheckPointsContinue;
+
+          for(const noBase& obj : world.GetFigures(curPt))
+          {
+              if(obj.GetObjId() != id_)
+                  continue;
+
+              const auto& movable = dynamic_cast<const noMovable&>(obj);
+              mapPt_ = curPt;
+              drawPt_ = world.GetNodePos(curPt);
+              if(movable.IsMoving())
+                  drawPt_ += movable.CalcWalkingRelative();
+
+              return CheckPointsBreak;
+          }
+          return CheckPointsContinue;
+      },
+      true);
+
+    if(!success)
+        Invalidate();
+
+    return success;
+}
+
+bool PickedMovableObject::Track(GameWorldView& gwv, bool moveTo)
+{
+    const auto success = Track(gwv);
+    if(success && moveTo)
+        gwv.MoveTo(drawPt_ - gwv.GetSize() / 2u);
+    return success;
+}

libs/s25main/PickedMovableObject.h

@@ -0,0 +1,43 @@
+// Copyright (C) 2005 - 2023 Settlers Freaks (sf-team at siedler25.org)
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "DrawPoint.h"
+#include "gameTypes/MapCoordinates.h"
+
+class GameWorldView;
+
+class PickedMovableObject
+{
+public:
+    static PickedMovableObject Pick(const GameWorldView& gwv, MapPoint mapPt, DrawPoint drawPt, bool expire);
+    static PickedMovableObject PickAtCursor(const GameWorldView& gwv, bool expire);
+    static PickedMovableObject PickAtViewCenter(const GameWorldView& gwv, bool expire);
+
+    PickedMovableObject() = default;
+
+    // disable implicit copy; may still be useful
+    explicit PickedMovableObject(const PickedMovableObject&) = default;
+    PickedMovableObject& operator=(const PickedMovableObject&) = default;
+
+    // invalidates the moved-from object
+    PickedMovableObject(PickedMovableObject&& other) noexcept;
+    PickedMovableObject& operator=(PickedMovableObject&& other) noexcept;
+
+    unsigned Id() const { return id_; }
+    bool IsValid() const;
+
+    void CancelExpiration();
+    void Invalidate();
+
+    bool Track(const GameWorldView& gwv);
+    bool Track(GameWorldView& gwv, bool moveTo);
+
+private:
+    unsigned id_ = 0;
+    MapPoint mapPt_{};
+    DrawPoint drawPt_{};
+    unsigned long expiration_ = static_cast<unsigned long>(-1) /* = ExpireNever */;
+};