Feature/hw10 threads

drone_simulation/CMakeLists.txt

@@ -6,6 +6,7 @@ add_library(drone_simulation_lib
     src/solvers/analytical_solver.cpp
     src/solvers/table_solver.cpp
     src/providers/json_target_provider.cpp
+    src/providers/thread_safe_target_provider.cpp
     src/config_loaders/file_config_loader.cpp
     src/config_loaders/factory.cpp
     src/mission_processor.cpp
@@ -14,7 +15,12 @@ add_library(drone_simulation_lib
     src/drone_states/state_decelerating.cpp
     src/drone_states/state_turning.cpp
     src/drone_states/state_moving.cpp
+    src/drone_physics.cpp
 )
+
+find_package(Threads REQUIRED)
+target_link_libraries(drone_simulation_lib PUBLIC Threads::Threads)
+
 target_include_directories(drone_simulation_lib PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
 target_compile_options(drone_simulation_lib PRIVATE -Wall -Wextra -pedantic)
 

drone_simulation/data/config.json

@@ -14,7 +14,10 @@
   "ammo": "VOG-17",
   "simulation": {
     "timeStep": 0.1,
-    "hitRadius": 2
+    "hitRadius": 2,
+    "targetTimeStep": 0.05,
+    "physicsTimeStep": 0.01,
+    "timeScale": 10.0
   },
   "targetArrayTimeStep": 1
 }

drone_simulation/include/config_loaders/factory.hpp

@@ -6,13 +6,10 @@
 #include "interfaces/target_provider.hpp"
 #include "interfaces/config_loader.hpp"
 
-enum class SolverType   {
-    ANALYTICAL,
-    TABLE
-};
-enum class ProviderType { JSON };
-enum class LoaderType   { FILE };
+enum class SolverType { ANALYTICAL, TABLE };
+enum class ProviderType { JSON, THREAD_SAFE };
+enum class LoaderType { FILE };
 
 std::unique_ptr<IBallisticSolver> createSolver(SolverType type, const DroneConfig& config, const std::string tablePath = "");
-std::unique_ptr<ITargetProvider> createProvider(ProviderType type, const std::string path);
+std::unique_ptr<ITargetProvider> createProvider(ProviderType type, const std::string path, float arrayTimeStep, float timeScale);
 std::unique_ptr<IConfigLoader> createLoader(LoaderType type, const std::string c, const std::string a);

drone_simulation/include/drone_physics.hpp

@@ -0,0 +1,33 @@
+#pragma once
+#include <cstring>
+#include <mutex>
+#include <atomic>
+#include "simulation.hpp"
+#include "thread_safe_queue.hpp"
+
+class DronePhysics {
+public:
+  DronePhysics(const DroneConfig& config);
+
+  auto sendCommand(const DroneCommand& cmd) -> void;
+  auto getTelemetry() const -> DroneTelemetry;
+  auto run() -> void;
+  auto start() -> void;
+  auto stop() -> void;
+  auto isThreadReady() const -> bool;
+
+private:
+  auto stepPhysics(float dt) -> void;
+  auto processState(float dt) -> void;
+
+  DroneContext droneContext;
+  DroneConfig config;
+  ThreadSafeQueue<DroneCommand> commandQueue;
+  mutable std::mutex mtx;
+  float elapsedTime = 0.0f;
+  float angleSpeed = 0.0f;
+  DroneStates currentState = DroneStates::Stopped;
+  std::atomic<bool> ready{false};
+  std::atomic<bool> running{false};
+  std::atomic<bool> stopFlag{false};
+};

drone_simulation/include/drone_states/state_accelerating.hpp

@@ -2,10 +2,9 @@
 #include "interfaces/drone_state.hpp"
 
 class StateAccelerating : public IDroneState {
-    public:
-        static constexpr const char* NAME = "ACCELERATING";
-        StateAccelerating();
+public:
+  StateAccelerating();
 
-        auto execute(DroneContext& ctx) -> std::unique_ptr<IDroneState> override;
-        auto name() const -> std::string override;
+  auto execute(const DroneStateInput& input) -> std::unique_ptr<IDroneState> override;
+  auto name() const -> DroneStates override;
 };

drone_simulation/include/drone_states/state_decelerating.hpp

@@ -2,10 +2,9 @@
 #include "interfaces/drone_state.hpp"
 
 class StateDecelerating : public IDroneState {
-    public:
-        static constexpr const char* NAME = "DECELERATING";
-        StateDecelerating();
+public:
+  StateDecelerating();
 
-        auto execute(DroneContext& context) -> std::unique_ptr<IDroneState> override;
-        auto name() const -> std::string override;
+  auto execute(const DroneStateInput& input) -> std::unique_ptr<IDroneState> override;
+  auto name() const -> DroneStates override;
 };

drone_simulation/include/drone_states/state_moving.hpp

@@ -2,10 +2,9 @@
 #include "interfaces/drone_state.hpp"
 
 class StateMoving : public IDroneState {
-    public:
-        static constexpr const char* NAME = "MOVING";
-        StateMoving();
+public:
+  StateMoving();
 
-        auto execute(DroneContext& context) -> std::unique_ptr<IDroneState> override;
-        auto name() const -> std::string override;
+  auto execute(const DroneStateInput& input) -> std::unique_ptr<IDroneState> override;
+  auto name() const -> DroneStates override;
 };

drone_simulation/include/drone_states/state_stopped.hpp

@@ -2,10 +2,9 @@
 #include "interfaces/drone_state.hpp"
 
 class StateStopped : public IDroneState {
-    public:
-        static constexpr const char* NAME = "STOPPED";
-        StateStopped();
+public:
+  StateStopped();
 
-        auto execute(DroneContext& context) -> std::unique_ptr<IDroneState> override;
-        auto name() const -> std::string override;
+  auto execute(const DroneStateInput& input) -> std::unique_ptr<IDroneState> override;
+  auto name() const -> DroneStates override;
 };

drone_simulation/include/drone_states/state_turning.hpp

@@ -2,10 +2,9 @@
 #include "interfaces/drone_state.hpp"
 
 class StateTurning : public IDroneState {
-    public:
-        static constexpr const char* NAME = "TURNING";
-        StateTurning();
+public:
+  StateTurning();
 
-        auto execute(DroneContext& context) -> std::unique_ptr<IDroneState> override;
-        auto name() const -> std::string override;
+  auto execute(const DroneStateInput& input) -> std::unique_ptr<IDroneState> override;
+  auto name() const -> DroneStates override;
 };

drone_simulation/include/interfaces/ballistic_solver.hpp

@@ -1,12 +1,13 @@
 #pragma once
-#include "../simulation.hpp"
+#include "simulation.hpp"
+
+struct BallisticResult {
+  float flightTime;
+  float hDist;
+};
 
 class IBallisticSolver {
 public:
-    virtual Coord solve(
-        const Coord& dronePosition,
-        const Coord& targetPosition,
-        const AmmoParams& ammmo
-    ) = 0;
-    virtual ~IBallisticSolver() {}
+  virtual BallisticResult solve(const AmmoParams& ammo) = 0;
+  virtual ~IBallisticSolver() {}
 };

drone_simulation/include/interfaces/config_loader.hpp

@@ -1,10 +1,10 @@
 #pragma once
-#include "../simulation.hpp"
+#include "simulation.hpp"
 
 class IConfigLoader {
 public:
-    virtual void load() = 0;
-    virtual DroneConfig getConfig() = 0;
-    virtual AmmoParams getAmmoParams() = 0;
-    virtual ~IConfigLoader() {}
+  virtual void load() = 0;
+  virtual DroneConfig getConfig() = 0;
+  virtual AmmoParams getAmmoParams() = 0;
+  virtual ~IConfigLoader() {}
 };

drone_simulation/include/interfaces/drone_state.hpp

@@ -5,13 +5,12 @@
 
 class IDroneState {
 public:
-    virtual ~IDroneState() = default;
-
-    // Виконати логіку стану, повернути наступний стан.
-    // Якщо стан не змінився — повернути nullptr
-    // (головний цикл залишить поточний).
-    virtual std::unique_ptr<IDroneState> execute(DroneContext& context) = 0;
-
-    virtual std::string name() const = 0;
-};
+  virtual ~IDroneState() = default;
+
+  // Виконати логіку стану, повернути наступний стан.
+  // Якщо стан не змінився — повернути nullptr
+  // (головний цикл залишить поточний).
+  virtual std::unique_ptr<IDroneState> execute(const DroneStateInput& input) = 0;
 
+  virtual DroneStates name() const = 0;
+};

drone_simulation/include/interfaces/target_provider.hpp

@@ -1,9 +1,9 @@
 #pragma once
-#include "../simulation.hpp"
+#include "simulation.hpp"
 
 class ITargetProvider {
 public:
-    virtual int getTargetCount() = 0;
-    virtual std::vector<Coord>& getTarget(int index) = 0;
-    virtual ~ITargetProvider() {}
+  virtual int getTargetCount() = 0;
+  virtual Target getTarget(int index) = 0;
+  virtual ~ITargetProvider() {}
 };

drone_simulation/include/mission_processor.hpp

@@ -1,36 +1,48 @@
 #pragma once
+#include <atomic>
+#include <thread>
+#include <vector>
 #include "interfaces/ballistic_solver.hpp"
 #include "interfaces/config_loader.hpp"
 #include "interfaces/target_provider.hpp"
 #include "interfaces/drone_state.hpp"
-
+#include "drone_physics.hpp"
 
 class MissionProcessor {
-    const int MAX_STEPS = 10000;
-    std::unique_ptr<ITargetProvider>  targets;
-    std::unique_ptr<IBallisticSolver> ballisticSolver;
-    DroneConfig droneConfig;
-    AmmoParams ammo;
-    DroneContext droneContext;
-    int currentStep = 1;
-    int prevTargetIndex = -1;
-    float currentTime = 0.0f;
-    float ammoFlightTime;
-    float ammoHorizontalFlightDistance;
-    bool hit = false;
-    std::unique_ptr<IDroneState> state;
+public:
+  MissionProcessor(std::unique_ptr<ITargetProvider> targetProvider, std::unique_ptr<IBallisticSolver> solver, DronePhysics* physics);
 
-    public:
-        MissionProcessor(std::unique_ptr<ITargetProvider> targetProvider, std::unique_ptr<IBallisticSolver> solver);
+  auto init(std::unique_ptr<IConfigLoader> configLoader) -> void;
+  auto getCurrentStep() -> int;
+  auto step() -> SimulationStep;
+  auto reset() -> void;
+  auto changeSolver(std::unique_ptr<IBallisticSolver> ballisticSolver) -> void;
+  auto run() -> void;
+  auto start() -> void;
+  auto isThreadReady() const -> bool;
+  auto getSteps() const -> const std::vector<SimulationStep>&;
 
-        auto init(std::unique_ptr<IConfigLoader> configLoader) -> void;
-        auto hasNext() -> bool;
-        auto getCurrentStep() -> int;
-        auto step() -> SimulationStep;
-        auto reset() -> void;
-        auto changeSolver(std::unique_ptr<IBallisticSolver> ballisticSolver) -> void;
+private:
+  auto evaluateTarget(int targetIndex, const DroneTelemetry& telemetry, Coord& outFireCoord) -> float;
+  auto getSimulationStep(int targetIndex, const Coord& fireCoord, const DroneTelemetry& telemetry) -> SimulationStep;
+  auto hasNext() -> bool;
 
-    private:
-        auto evaluateTarget(int targetIndex, float currentTime, Coord& outFireCoord) -> float;
-        auto getSimulationStep(int targetIndex, const Coord& fireCoord) -> SimulationStep;
-};
+  const int MAX_STEPS = 10000;
+  std::unique_ptr<ITargetProvider> targets;
+  std::unique_ptr<IBallisticSolver> ballisticSolver;
+  DroneConfig droneConfig;
+  AmmoParams ammo;
+  int currentStep = 1;
+  int prevTargetIndex = -1;
+  float currentTime = 0.0f;
+  float ammoFlightTime;
+  float ammoHorizontalFlightDistance;
+  float acceleration;
+  float prevDirectionToTarget = 0.0f;
+  bool hit = false;
+  DronePhysics* dronePhysics;
+  std::atomic<bool> ready{false};
+  std::atomic<bool> running{false};
+  std::vector<SimulationStep> simulationSteps;
+  std::unique_ptr<IDroneState> droneState;
+};

drone_simulation/include/providers/json_target_provider.hpp

@@ -4,13 +4,13 @@
 #include "interfaces/target_provider.hpp"
 
 class JsonTargetProvider : public ITargetProvider {
-    std::vector<std::vector<Coord>> targets;
-    int count;
+  std::vector<std::vector<Coord>> targets;
+  int count;
 
-    public:
-        JsonTargetProvider(const std::string path);
-        ~JsonTargetProvider() override;
-        
-        auto getTargetCount() -> int override;
-        auto getTarget(int i) -> std::vector<Coord>& override;
+public:
+  JsonTargetProvider(const std::string path);
+  ~JsonTargetProvider() override;
+
+  auto getTargetCount() -> int override;
+  auto getTarget(int i) -> Target override;
 };

drone_simulation/include/providers/thread_safe_target_provider.hpp

@@ -0,0 +1,32 @@
+#pragma once
+#include <cstring>
+#include <vector>
+#include <atomic>
+#include "interfaces/target_provider.hpp"
+
+class ThreadSafeTargetProvider : public ITargetProvider {
+public:
+  ThreadSafeTargetProvider(const std::string path, float arrayTimeStep, float timeScale);
+  ~ThreadSafeTargetProvider() override;
+
+  auto getTargetCount() -> int override;
+  auto getTarget(int i) -> Target override;
+  auto run() -> void;
+  auto start() -> void;
+  auto stop() -> void;
+  auto isThreadReady() const -> bool;
+
+private:
+  auto updateTargets() -> void;
+
+  std::vector<std::vector<Coord>> trajectories;
+  std::vector<Target> currentTargets;
+  std::vector<int> currentIndex;
+  float arrayTimeStep;
+  int count;
+  float timeScale;
+  mutable std::mutex mtx;
+  std::atomic<bool> ready{false};
+  std::atomic<bool> running{false};
+  std::atomic<bool> stopFlag{false};
+};