Add basic member functions to character (#12)

* Add basic member functions to character
Remove bot and weapon name from states
Remove texture maps
Remove unnecessary dependencies

* Fix threading problem and make weapon states synchronized with game clock

* Remove hardcoded style from texture manager

* Add middle class for enemy state for enemy specific members

* Update animation

* Create single ray caster service for bots

* Add object id field in ray

* Move camera into player instead of having them separate

* Create shooting manager

* Update enemy states and use shooting logic

CMakeLists.txt

@@ -59,6 +59,7 @@ add_subdirectory(src/Graphics)
 add_subdirectory(src/Map)
 add_subdirectory(src/Math)
 add_subdirectory(src/NavigationManager)
+add_subdirectory(src/ShootingManager)
 add_subdirectory(src/Strike)
 add_subdirectory(src/State)
 add_subdirectory(src/TextureManager)

src/Animation/CMakeLists.txt

@@ -6,4 +6,9 @@ add_library(
 target_include_directories(animation PUBLIC
     ${CMAKE_CURRENT_SOURCE_DIR}/include
 )
+target_link_libraries(
+    animation 
+    PUBLIC
+    texture_manager
+)
 

src/Animation/include/Animation/animation.h

@@ -22,6 +22,7 @@ class IAnimation
 	virtual void Update(const double& delta_time) = 0;
 	virtual void Reset() = 0;
 	virtual int GetCurrentFrame() const = 0;
+	virtual bool IsAnimationFinishedOnce() const = 0;
 };
 
 }  // namespace wolfenstein

src/Animation/include/Animation/time_based_single_animation.h

@@ -14,6 +14,7 @@
 
 #include "Animation/animation.h"
 #include <cstdint>
+#include <string>
 #include <vector>
 
 namespace wolfenstein {
@@ -23,18 +24,23 @@ class TBSAnimation : public IAnimation
   public:
 	TBSAnimation(const std::vector<uint16_t>& textures,
 				 const double animation_speed);
+	TBSAnimation(const std::string collection_name,
+				 const double animation_speed);
 	~TBSAnimation() = default;
 
 	void Update(const double& delta_time) override;
 	void Reset() override;
 
 	int GetCurrentFrame() const override;
+	bool IsAnimationFinishedOnce() const override;
 
   private:
 	std::vector<uint16_t> textures;
+	int textures_size;
 	int current_frame;
 	double animation_speed;
 	double counter;
+	bool is_animation_finished_once;
 };
 
 }  // namespace wolfenstein

src/Animation/src/time_based_single_animation.cpp

@@ -1,19 +1,34 @@
 #include "Animation/time_based_single_animation.h"
-
+#include "TextureManager/texture_manager.h"
 namespace wolfenstein {
 
 TBSAnimation::TBSAnimation(const std::vector<uint16_t>& textures,
 						   const double animation_speed)
 	: textures(textures),
+	  textures_size(textures.size()),
 	  current_frame(0),
 	  animation_speed(animation_speed),
-	  counter(0) {}
+	  counter(0),
+	  is_animation_finished_once(false) {}
+
+TBSAnimation::TBSAnimation(const std::string collection_name,
+						   const double animation_speed)
+	: textures(
+		  TextureManager::GetInstance().GetTextureCollection(collection_name)),
+	  textures_size(textures.size()),
+	  current_frame(0),
+	  animation_speed(animation_speed / textures_size),
+	  counter(0),
+	  is_animation_finished_once(false) {}
 
 void TBSAnimation::Update(const double& delta_time) {
 	counter += delta_time;
-	if (counter > animation_speed) {
-		current_frame = (current_frame + 1) % textures.size();
+	if (counter >= animation_speed) {
+		current_frame = (current_frame + 1) % textures_size;
 		counter = 0;
+		if (!is_animation_finished_once && current_frame == textures_size - 1) {
+			is_animation_finished_once = true;
+		}
 	}
 }
 
@@ -26,4 +41,8 @@ int TBSAnimation::GetCurrentFrame() const {
 	return textures[current_frame];
 }
 
+bool TBSAnimation::IsAnimationFinishedOnce() const {
+	return is_animation_finished_once;
+}
+
 }  // namespace wolfenstein

src/Camera/CMakeLists.txt

@@ -27,9 +27,22 @@ target_link_libraries(
     PUBLIC
     game_object
     ray
-    character
-    vector
-    map
     scene
-    texture_manager
+    vector
+)
+
+add_library(
+    single_raycaster
+    STATIC
+    src/single_raycaster.cpp
 )
+target_include_directories(single_raycaster PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+target_link_libraries(
+    single_raycaster
+    PUBLIC
+    ray
+    vector
+    map
+)

src/Camera/include/Camera/camera.h

@@ -14,11 +14,7 @@
 
 #include "Camera/ray.h"
 #include "Camera/raycaster.h"
-#include "Characters/character.h"
-#include "Core/scene.h"
 #include "GameObjects/game_object.h"
-#include "GameObjects/static_object.h"
-#include "Map/map.h"
 
 #include <memory>
 #include <optional>
@@ -28,20 +24,26 @@ namespace wolfenstein {
 
 struct Camera2DConfig
 {
+	Camera2DConfig(int width, double fov, double depth)
+		: width(width), fov(fov), depth(depth) {}
+
 	int width;
 	double fov;
 	double depth;
 };
 
 typedef std::pair<Ray, Ray> RayPair;
 
+class Scene;
 class Camera2D
 {
   public:
-	explicit Camera2D(const Camera2DConfig& config);
+	explicit Camera2D(const Camera2DConfig& config,
+					  const std::shared_ptr<Scene>& scene);
 	~Camera2D() = default;
 
 	void Update(const std::shared_ptr<Scene>& scene);
+	void Update();
 
 	std::shared_ptr<RayVector> GetRays() const;
 	std::shared_ptr<Ray> GetCrosshairRay() const;
@@ -58,6 +60,7 @@ class Camera2D
 	double WorldAngleToCameraAngle(double angle) const;
 
 	Camera2DConfig config_;
+	std::shared_ptr<Scene> scene_;
 	Position2D position_;
 	std::shared_ptr<RayCaster> ray_cast_;
 	std::shared_ptr<RayVector> rays_;

src/Camera/include/Camera/ray.h

@@ -14,6 +14,7 @@
 
 #include "Math/vector.h"
 
+#include <string>
 #include <vector>
 
 namespace wolfenstein {
@@ -35,6 +36,7 @@ struct Ray
 	double perpendicular_distance;
 
 	int wall_id;
+	std::string object_id;
 
 	bool is_hit;
 	bool is_hit_vertical;

src/Camera/include/Camera/single_raycaster.h

@@ -0,0 +1,50 @@
+/**
+ * @file single_raycaster.h
+ * @author Bilal Kahraman ([email protected])
+ * @brief 
+ * @version 0.1
+ * @date 2024-11-05
+ * 
+ * @copyright Copyright (c) 2024
+ * 
+ */
+
+#ifndef CAMERA_INCLUDE_CAMERA_SINGLE_RAYCASTER_H_
+#define CAMERA_INCLUDE_CAMERA_SINGLE_RAYCASTER_H_
+
+#include "Camera/ray.h"
+#include "Map/map.h"
+#include "Math/vector.h"
+
+#include <memory>
+
+namespace wolfenstein {
+
+class SingleRayCasterService
+{
+  public:
+	static SingleRayCasterService& GetInstance();
+	SingleRayCasterService(const SingleRayCasterService&) = delete;
+	SingleRayCasterService& operator=(const SingleRayCasterService&) = delete;
+	~SingleRayCasterService() = default;
+
+	void InitService(const std::shared_ptr<Map>& map_ptr);
+	Ray Cast(const vector2d& src);
+
+	void SubscribePlayerPose(const vector2d& pose);
+
+  private:
+	SingleRayCasterService() = default;
+
+	void PrepareRay(const vector2d& src, Ray& ray, vector2d& ray_unit_step,
+					vector2d& ray_length_1d, vector2i& step,
+					vector2i& map_check);
+
+	vector2d dest{0, 0};
+	std::shared_ptr<Map> map_ptr_;
+	static SingleRayCasterService* instance_;
+};
+
+}  // namespace wolfenstein
+
+#endif	// CAMERA_INCLUDE_CAMERA_SINGLE_RAYCASTER_H_

src/Camera/src/camera.cpp

@@ -11,10 +11,11 @@
 
 #include "Camera/camera.h"
 #include "Camera/ray.h"
+#include "Core/scene.h"
 #include "Math/vector.h"
-#include "TextureManager/texture_manager.h"
 
 #include <cmath>
+#include <memory>
 #include <string>
 
 namespace wolfenstein {
@@ -26,23 +27,24 @@ void Camera2D::InitRays() {
 	}
 }
 
-Camera2D::Camera2D(const Camera2DConfig& config)
+Camera2D::Camera2D(const Camera2DConfig& config,
+				   const std::shared_ptr<Scene>& scene)
 	: config_(config),
+	  scene_(scene),
 	  ray_cast_(std::make_shared<RayCaster>(config.width / 2, config.fov,
 											config.depth)) {
 	InitRays();
 }
 
-void Camera2D::Update(const std::shared_ptr<Scene>& scene) {
-	ray_cast_->Update(scene->GetMap(), position_, rays_);
+void Camera2D::Update() {
+	ray_cast_->Update(scene_->GetMap(), position_, rays_);
 	crosshair_ray_ = std::make_shared<Ray>(rays_->at(config_.width / 4));
+	crosshair_ray_->is_hit = false;
 
 	// Update object rays
 	objects_.clear();
-	for (const auto& object : scene->GetObjects()) {
-		if (object->GetObjectType() != ObjectType::CHARACTER_PLAYER) {
-			Calculate(object);
-		}
+	for (const auto& object : scene_->GetObjects()) {
+		Calculate(object);
 	}
 }
 
@@ -135,6 +137,15 @@ void Camera2D::Calculate(const std::shared_ptr<IGameObject>& object) {
 	object_ray_pair.second.wall_id = texture_id;
 
 	objects_[object->GetId()] = object_ray_pair;
+
+	// Calculate if the object is in the crosshair
+	if (object_distance < crosshair_ray_->perpendicular_distance &&
+		camera_angle_left <= 0 && camera_angle_right >= 0) {
+		crosshair_ray_->is_hit = true;
+		crosshair_ray_->perpendicular_distance = object_distance;
+		crosshair_ray_->object_id = object->GetId();
+		crosshair_ray_->hit_point = object_pose;
+	}
 }
 
 double Camera2D::WorldAngleToCameraAngle(double angle) const {

src/Camera/src/ray.cpp

@@ -12,6 +12,7 @@ Ray::Ray()
 	  distance(0),
 	  perpendicular_distance(0),
 	  wall_id(0),
+	  object_id(""),
 	  is_hit(false),
 	  is_hit_vertical(false) {}
 
@@ -23,6 +24,7 @@ Ray::Ray(vector2d direction_, double theta_)
 	  distance(0),
 	  perpendicular_distance(0),
 	  wall_id(0),
+	  object_id(""),
 	  is_hit(false),
 	  is_hit_vertical(false) {}
 
@@ -37,6 +39,7 @@ void Ray::Reset(const vector2d ray_orig, const double ray_theta) {
 	distance = 0;
 	perpendicular_distance = 0;
 	wall_id = 0;
+	object_id = "";
 	is_hit = false;
 	is_hit_vertical = false;
 }