gameObject.h

Go to the documentation of this file.

#pragma once
 
#include <engine/public/component.h>
#include <engine/public/transform.h>
 
#include <algorithm>
#include <optional>
#include <ranges>
#include <string>
#include <vector>
 
class Scene;
 
class GameObject {
 private:
  std::string id_;
 
  std::vector<std::unique_ptr<Component>> components_;
  std::vector<std::reference_wrapper<GameObject>> children_;
 
  std::optional<std::reference_wrapper<GameObject>> parent_;
  bool is_active_{true};
  bool is_active_in_world_{true};
 
  std::string name_;
  std::string tag_;
  int layer_{};
  std::reference_wrapper<Scene> scene_;
  Transform transform_;
 
  bool marked_for_deletion_{false};
  bool dont_destroy_on_load_{false};
  std::string prefab_type_id_{};  // Identifier for prefab type used during
                                  // network replication
 
 public:
  explicit GameObject(Scene& scene);
  virtual ~GameObject() = default;
 
  GameObject(const GameObject&) = delete;
  GameObject& operator=(const GameObject&) = delete;
 
  GameObject(GameObject&&) = default;
  GameObject& operator=(GameObject&&) = default;
 
  std::optional<std::reference_wrapper<GameObject>> parent() const;  // NOLINT
  GameObject& parent(GameObject& parent);
  GameObject& parent(std::nullopt_t null_opt);
 
  [[nodiscard]] std::string id() const noexcept;
 
  [[nodiscard]] bool is_active_in_world() const noexcept;
 
  [[nodiscard]] bool is_active() const noexcept;
 
  void set_inactive() noexcept;
  void set_active() noexcept;
  void set_active_in_world() noexcept;
  void set_inactive_in_world() noexcept;
 
  GameObject& mark_for_deletion() noexcept;
  [[nodiscard]] bool marked_for_deletion() const noexcept;
 
  void mark_dont_destroy_on_load(bool dont_destroy) noexcept;
  bool dont_destroy_on_load() const noexcept;
 
  GameObject& name(const std::string& name);
  [[nodiscard]] const std::string& name() const;
 
  GameObject& tag(const std::string& tag);
  [[nodiscard]] const std::string& tag() const;
 
  GameObject& prefab_type_id(const std::string& id);
  [[nodiscard]] const std::string& prefab_type_id() const;
 
  GameObject& layer(int layer);
  [[nodiscard]] int layer() const;
 
  GameObject& transform(Transform transform);
  [[nodiscard]] Transform& transform();
  [[nodiscard]] const Transform& transform() const;
 
  [[nodiscard]] Scene& scene() const noexcept;
  void scene(Scene& scene) noexcept;
 
  [[nodiscard]] std::vector<std::reference_wrapper<GameObject>>& children();
  GameObject& add_child(GameObject& child);
  GameObject& remove_child(GameObject& child);
 
  template <IsComponent T>
  [[nodiscard]] std::optional<std::reference_wrapper<T>> get_component()
      const noexcept {
    for (const auto& component : components_) {
      if (auto* casted = dynamic_cast<T*>(component.get())) {
        return std::ref(*casted);
      }
    }
    return std::nullopt;
  }
 
  template <IsComponent T>
  [[nodiscard]] std::vector<std::reference_wrapper<T>> get_components() const {
    auto filtered =
        components_ |
        std::views::filter([](auto& c) { return dynamic_cast<T*>(c.get()); }) |
        std::views::transform([](auto& c) -> std::reference_wrapper<T> {
          return std::ref(*static_cast<T*>(c.get()));
        });
 
    return std::vector<std::reference_wrapper<T>>(filtered.begin(),
                                                  filtered.end());
  }
 
  template <IsComponent BS, typename B>
  [[nodiscard]] std::optional<std::reference_wrapper<B>> get_script()
      const noexcept {
    auto scripts = get_components<BS>();
 
    for (const auto& script : scripts) {
      if (auto& behavior = script.get().behavior();
          dynamic_cast<B*>(&behavior)) {
        return std::ref(static_cast<B&>(behavior));
      }
    }
 
    return std::nullopt;
  }
 
  [[nodiscard]] std::vector<std::reference_wrapper<Component>>
  get_components_all() const;
 
  template <IsComponent T>
  std::vector<std::reference_wrapper<T>> get_components_from_children() const {
    std::vector<std::reference_wrapper<T>> result{};
 
    for (const auto& child : children_) {
      auto child_components = child.get().get_components_from_children<T>();
      result.insert(result.end(), child_components.begin(),
                    child_components.end());
    }
 
    return result;
  }
 
  template <IsComponent T, typename... Args>
  T& add_component(Args&&... args) {
    auto component = std::make_unique<T>(std::forward<Args>(args)...);
    T& ref = *component;
 
    component->parent(std::ref(*this));
    component->on_attach();
 
    components_.emplace_back(std::move(component));
    return ref;
  }
 
  template <IsComponent T>
  void remove_component(T& component) {
    component.on_detach();
    component.parent(std::nullopt);
 
    components_.erase(
        std::remove_if(components_.begin(), components_.end(),
                       [&component](const std::unique_ptr<Component>& c) {
                         return c.get() == &component;
                       }),
        components_.end());
  }
 
  void remove_all_components();
 
  void serialize(std::vector<uint8_t>& out) const;
 
  void deserialize(const std::vector<uint8_t>& data, size_t& offset);
};