diff options
59 files changed, 1424 insertions, 492 deletions
diff --git a/.clang-tidy b/.clang-tidy index 3408f75..4d8170b 100644 --- a/.clang-tidy +++ b/.clang-tidy @@ -20,6 +20,8 @@ CheckOptions: value: '_.*' - key: 'readability-identifier-naming.ConstantParameterCase' value: 'lower_case' + - key: 'readability-identifier-naming.ConstantMemberCase' + value: 'lower_case' - key: 'readability-identifier-naming.VariableCase' value: 'lower_case' - key: 'readability-identifier-naming.VariableIgnoredRegexp' diff --git a/contributing.md b/contributing.md index 2fe46f7..8799057 100644 --- a/contributing.md +++ b/contributing.md @@ -49,11 +49,13 @@ that you can click on to open them. class Cars {}; ``` </td></tr></table></details> -- Source files contain the following types of comments: +- Source files (`.cpp`, `.hpp`) contain the following types of comments: - What is the code supposed to do (optional) - Implementation details (if applicable) -- Header files contain the following types of comments: - - Usage documentation (required) +- Header files (`.h`) contain the following types of comments: + - [Usage documentation](#documentation) (required) + > [!NOTE] + > Constructors/destructors aren't required to have a `\brief` description - Implementation details (if they affect the header) - Design/data structure decisions (if applicable) - <details><summary> @@ -76,8 +78,8 @@ that you can click on to open them. } ``` </td></tr></table></details> -- Header includes are split into paragraphs separated by a blank line. The - order is: +- Header includes (at the top of files) are split into paragraphs separated by + a blank line. The order is: 1. system headers (using `<`brackets`>`) 2. relative headers NOT in the same folder as the current file 3. relative headers in the same folder as the current file @@ -110,7 +112,54 @@ that you can click on to open them. ``` </td></tr></table></details> - <details><summary> - <code>using namespace</code> may not be used in header files, only in source files. + If there is one, the matching template header (<code>.hpp</code>) is included + at the bottom of the regular header (<code>.h</code>) + </summary><table><tr><th>Good</th><th>Bad</th></tr><tr><td> + + Foo.h: + ```cpp + #pragma once + + template <typename T> + void foo(); + + #include "Foo.hpp" + ``` + + Foo.hpp: + ```cpp + #pragma once + #include "Foo.h" + + template <typename T> + void foo() { + // ... + } + ``` + </td><td> + + Foo.h: + ```cpp + #pragma once + + template <typename T> + void foo(); + ``` + + Foo.hpp: + ```cpp + #pragma once + #include "Foo.h" + + template <typename T> + void foo() { + // ... + } + ``` + </td></tr></table></details> +- <details><summary> + <code>using namespace</code> may not be used in header files (.h, .hpp), only + in source files (.cpp). </summary><table><tr><th>Good</th><th>Bad</th></tr><tr><td> example.h: @@ -277,7 +326,7 @@ that you can click on to open them. ```cpp struct Foo { - int bar; + int bar = 0; std::string baz; }; ``` @@ -285,7 +334,7 @@ that you can click on to open them. ```cpp struct Foo { - int bar = 0; + int bar; std::string baz; }; ``` @@ -386,6 +435,223 @@ that you can click on to open them. #endif ``` </td></tr></table></details> +- <details><summary> + Variables that are being moved always use the fully qualified <code>std::move</code> + </summary><table><tr><th>Good</th><th>Bad</th></tr><tr><td> + + ```cpp + using namespace std; + string foo = "bar"; + ref_fn(std::move(foo)); + ``` + </td><td> + + ```cpp + using namespace std; + string foo = "bar"; + ref_fn(move(foo)); + ``` + </td></tr></table></details> +- <details><summary> + If possible, classes and structs are passed to functions by (const) reference + </summary><table><tr><th>Good</th><th>Bad</th></tr><tr><td> + + ```cpp + void foo(const Point & p); + ``` + </td><td> + + ```cpp + void foo(Point & p); + void bar(Point p); + ``` + </td></tr></table></details> +- <details><summary> + Follow the rule of five + </summary><table><tr><th>Good</th><th>Bad</th></tr><tr><td> + + ```cpp + class Foo { + public: + Foo(); + ~Foo(); + Foo(Foo &&) noexcept; + Foo & operator = (const Foo &); + Foo & operator = (Foo &&) noexcept; + }; + ``` + </td><td> + + ```cpp + class Foo { + public: + Foo(); + ~Foo(); + }; + ``` + </td></tr></table></details> +- <details><summary> + Ensure const-correctness + </summary><table><tr><th>Good</th><th>Bad</th></tr><tr><td> + + ```cpp + class Foo { + public: + int get_value() const; + void set_value(int new_value); + const std::string & get_name() const; + void set_name(const std::string & new_name); + private: + int value; + std::string name; + }; + ``` + </td><td> + + ```cpp + class Foo { + public: + int get_value(); + void set_value(int new_value); + std::string get_name(); + void set_name(std::string new_name); + private: + int value; + std::string name; + }; + ``` + </td></tr></table></details> +- <details><summary> + Files should be named after the class/struct/interface they implement + </summary><table><tr><th>Good</th><th>Bad</th></tr><tr><td> + + ```cpp + MyClass.h + MyClass.cpp + MyClass.hpp + ``` + </td><td> + + ```cpp + my_class.h + myClass.cpp + my-class.hpp + ``` + </td></tr></table></details> +- <details><summary> + Implementations are not allowed in header files, except if the implementation + + - is `= default` + - is `= delete` + - is `{}` (empty) + - only returns a constant literal + </summary><table><tr><th>Good</th><th>Bad</th></tr><tr><td> + + ```cpp + class Foo { + public: + int get_value() const { return 42; } + }; + ``` + </td><td> + + ```cpp + class Foo { + public: + int calculate_value() const { + int result = 0; + // complex calculation + return result; + } + }; + ``` + </td></tr></table></details> +- <details><summary> + Use angle brackets (<code><></code>) only for including system headers and + double quotes (<code>""</code>) for including other engine files. + + > [!NOTE] + > Only files in the examples folder should include engine headers with angle + > brackets + </summary><table><tr><th>Good</th><th>Bad</th></tr><tr><td> + + ```cpp + #include <iostream> + + #include "facade/Sound.h" + ``` + </td><td> + + ```cpp + #include <iostream> + #include <crepe/facade/Sound.h> + ``` + </td></tr></table></details> +- <details><summary> + Ensure exception safety by using RAII classes + </summary><table><tr><th>Good</th><th>Bad</th></tr><tr><td> + + ```cpp + auto foo = std::make_unique<Foo>(); + ``` + </td><td> + + ```cpp + Foo* foo = new Foo(); + // ... + delete foo; + ``` + </td></tr></table></details> +- <details><summary> + Do not use C-style memory management APIs (<code>malloc</code>, + <code>calloc</code>, <code>free</code>) + </summary><table><tr><th>Good</th><th>Bad</th></tr><tr><td> + + ```cpp + Foo * foo = new Foo(); + delete foo; + ``` + </td><td> + + ```cpp + Foo * foo = (Foo *) malloc(sizeof(Foo)); + free(foo); + ``` + </td></tr></table></details> +- <details><summary> + Prefix all class members with <code>this-></code> + </summary><table><tr><th>Good</th><th>Bad</th></tr><tr><td> + + ```cpp + void Foo::set_value(int value) { + this->value = value; + } + ``` + </td><td> + + ```cpp + void Foo::set_value(int new_value) { + value = new_value; + } + ``` + </td></tr></table></details> +- <details><summary> + Assigning booleans should be done with the + <code>true</code>/<code>false</code> literals instead of + <code>0</code>/<code>1</code> + </summary><table><tr><th>Good</th><th>Bad</th></tr><tr><td> + + ```cpp + bool foo = true; + bool bar = false; + ``` + </td><td> + + ```cpp + bool foo = 1; + bool bar = 0; + ``` + </td></tr></table></details> ## CMakeLists-specific diff --git a/src/crepe/Collider.cpp b/src/crepe/Collider.cpp index 13a3f33..bbec488 100644 --- a/src/crepe/Collider.cpp +++ b/src/crepe/Collider.cpp @@ -2,4 +2,4 @@ using namespace crepe; -Collider::Collider(uint32_t gameObjectId) : Component(gameObjectId) {} +Collider::Collider(game_object_id_t id) : Component(id) {} diff --git a/src/crepe/Collider.h b/src/crepe/Collider.h index 68a7d1d..827f83d 100644 --- a/src/crepe/Collider.h +++ b/src/crepe/Collider.h @@ -6,7 +6,7 @@ namespace crepe { class Collider : public Component { public: - Collider(uint32_t game_object_id); + Collider(game_object_id_t id); int size; }; diff --git a/src/crepe/Component.cpp b/src/crepe/Component.cpp index 358ce31..73c2d07 100644 --- a/src/crepe/Component.cpp +++ b/src/crepe/Component.cpp @@ -1,5 +1,6 @@ #include "Component.h" +#include "types.h" using namespace crepe; -Component::Component(uint32_t id) : game_object_id(id), active(true) {} +Component::Component(game_object_id_t id) : game_object_id(id) {} diff --git a/src/crepe/Component.h b/src/crepe/Component.h index bc44865..0fe60b2 100644 --- a/src/crepe/Component.h +++ b/src/crepe/Component.h @@ -1,22 +1,46 @@ #pragma once +#include "types.h" + #include <cstdint> namespace crepe { class ComponentManager; +/** + * \brief Base class for all components + * + * This class is the base class for all components. It provides a common + * interface for all components. + */ class Component { protected: + //! Only the ComponentManager can create components friend class crepe::ComponentManager; - Component(uint32_t id); + /** + * \param id The id of the GameObject this component belongs to + */ + Component(game_object_id_t id); public: virtual ~Component() = default; + /** + * \brief Get the maximum number of instances for this component + * + * This method returns -1 by default, which means that there is no limit + * for the number of instances. Concrete components can override this method + * to set a limit. + * + * \return The maximum number of instances for this component + */ + virtual int get_instances_max() const { return -1; } public: - uint32_t game_object_id; - bool active; + //! The id of the GameObject this component belongs to + const game_object_id_t game_object_id; + //! Whether the component is active + bool active = true; }; } // namespace crepe diff --git a/src/crepe/ComponentManager.cpp b/src/crepe/ComponentManager.cpp index 8bde33a..85149c8 100644 --- a/src/crepe/ComponentManager.cpp +++ b/src/crepe/ComponentManager.cpp @@ -1,6 +1,7 @@ -#include "ComponentManager.h" #include "util/log.h" +#include "ComponentManager.h" + using namespace crepe; ComponentManager & ComponentManager::get_instance() { @@ -8,9 +9,9 @@ ComponentManager & ComponentManager::get_instance() { return instance; } -void ComponentManager::delete_all_components_of_id(uint32_t id) { +void ComponentManager::delete_all_components_of_id(game_object_id_t id) { // Loop through all the types (in the unordered_map<>) - for (auto & [type, componentArray] : components) { + for (auto & [type, componentArray] : this->components) { // Make sure that the id (that we are looking for) is within the boundaries of the vector<> if (id < componentArray.size()) { // Clear the components at this specific id diff --git a/src/crepe/ComponentManager.h b/src/crepe/ComponentManager.h index 2b5e1df..c8c196c 100644 --- a/src/crepe/ComponentManager.h +++ b/src/crepe/ComponentManager.h @@ -10,47 +10,110 @@ namespace crepe { +/** + * \brief Manages all components + * + * This class manages all components. It provides methods to add, delete and get + * components. + */ class ComponentManager { public: - // Singleton + /** + * \brief Get the instance of the ComponentManager + * + * \return The instance of the ComponentManager + */ static ComponentManager & get_instance(); ComponentManager(const ComponentManager &) = delete; ComponentManager(ComponentManager &&) = delete; ComponentManager & operator=(const ComponentManager &) = delete; ComponentManager & operator=(ComponentManager &&) = delete; + ~ComponentManager(); -public: - //! Add a component of a specific type + /** + * \brief Add a component to the ComponentManager + * + * This method adds a component to the ComponentManager. The component is + * created with the given arguments and added to the ComponentManager. + * + * \tparam T The type of the component + * \tparam Args The types of the arguments + * \param id The id of the GameObject this component belongs to + * \param args The arguments to create the component + * \return The created component + */ template <typename T, typename... Args> - T & add_component(uint32_t id, Args &&... args); - //! Deletes all components of a specific type and id + T & add_component(game_object_id_t id, Args &&... args); + /** + * \brief Delete all components of a specific type and id + * + * This method deletes all components of a specific type and id. + * + * \tparam T The type of the component + * \param id The id of the GameObject this component belongs to + */ template <typename T> - void delete_components_by_id(uint32_t id); - //! Deletes all components of a specific type + void delete_components_by_id(game_object_id_t id); + /** + * \brief Delete all components of a specific type + * + * This method deletes all components of a specific type. + * + * \tparam T The type of the component + */ template <typename T> void delete_components(); - //! Deletes all components of a specific id - void delete_all_components_of_id(uint32_t id); - //! Deletes all components + /** + * \brief Delete all components of a specific id + * + * This method deletes all components of a specific id. + * + * \param id The id of the GameObject this component belongs to + */ + void delete_all_components_of_id(game_object_id_t id); + /** + * \brief Delete all components + * + * This method deletes all components. + */ void delete_all_components(); - - //! Get a vector<> of all components at specific type and id + /** + * \brief Get all components of a specific type and id + * + * This method gets all components of a specific type and id. + * + * \tparam T The type of the component + * \param id The id of the GameObject this component belongs to + * \return A vector of all components of the specific type and id + */ template <typename T> std::vector<std::reference_wrapper<T>> - get_components_by_id(uint32_t id) const; - //! Get a vector<> of all components of a specific type + get_components_by_id(game_object_id_t id) const; + /** + * \brief Get all components of a specific type + * + * This method gets all components of a specific type. + * + * \tparam T The type of the component + * \return A vector of all components of the specific type + */ template <typename T> std::vector<std::reference_wrapper<T>> get_components_by_type() const; private: ComponentManager(); - virtual ~ComponentManager(); - /* - * The std::unordered_map<std::type_index, std::vector<std::vector<std::unique_ptr<Component>>>> below might seem a bit strange, let me explain this structure: - * The std::unordered_map<> has a key and value. The key is a std::type_index and the value is a std::vector. So, a new std::vector will be created for each new std::type_index. - * The first std::vector<> stores another vector<>. This first vector<> is to bind the entity's id to a component. - * The second std::vector<> stores unique_ptrs. Each component can be gathered via an unique_ptr. This second vector<> allows multiple components of the same std::type_index for one entity (id). +private: + /** + * \brief The components + * + * This unordered_map stores all components. The key is the type of the + * component and the value is a vector of vectors of unique pointers to the + * components. + * Every component type has its own vector of vectors of unique pointers to + * the components. The first vector is for the ids of the GameObjects and the + * second vector is for the components (because a GameObject might have multiple + * components). */ std::unordered_map<std::type_index, std::vector<std::vector<std::unique_ptr<Component>>>> diff --git a/src/crepe/ComponentManager.hpp b/src/crepe/ComponentManager.hpp index 9b07f13..98efb49 100644 --- a/src/crepe/ComponentManager.hpp +++ b/src/crepe/ComponentManager.hpp @@ -3,11 +3,12 @@ #include <type_traits> #include "ComponentManager.h" +#include "types.h" namespace crepe { template <class T, typename... Args> -T & ComponentManager::add_component(uint32_t id, Args &&... args) { +T & ComponentManager::add_component(game_object_id_t id, Args &&... args) { using namespace std; static_assert(is_base_of<Component, T>::value, @@ -17,38 +18,51 @@ T & ComponentManager::add_component(uint32_t id, Args &&... args) { type_index type = typeid(T); // Check if this component type is already in the unordered_map<> - if (components.find(type) == components.end()) { + if (this->components.find(type) == this->components.end()) { //If not, create a new (empty) vector<> of vector<unique_ptr<Component>> - components[type] = vector<vector<unique_ptr<Component>>>(); + this->components[type] = vector<vector<unique_ptr<Component>>>(); } // Resize the vector<> if the id is greater than the current size - if (id >= components[type].size()) { + if (id >= this->components[type].size()) { // Initialize new slots to nullptr (resize does automatically init to nullptr) - components[type].resize(id + 1); + this->components[type].resize(id + 1); } // Create a new component of type T (arguments directly forwarded). The // constructor must be called by ComponentManager. - T * instance = new T(id, forward<Args>(args)...); + T * instance_ptr = new T(id, forward<Args>(args)...); + if (instance_ptr == nullptr) throw std::bad_alloc(); + + T & instance_ref = *instance_ptr; + unique_ptr<T> instance = unique_ptr<T>(instance_ptr); + + // Check if the vector size is not greater than get_instances_max + int max_instances = instance->get_instances_max(); + if (max_instances != -1 && components[type][id].size() >= max_instances) { + // TODO: Exception + throw std::runtime_error( + "Exceeded maximum number of instances for this component type"); + } + // store its unique_ptr in the vector<> - components[type][id].push_back(unique_ptr<T>(instance)); + this->components[type][id].push_back(std::move(instance)); - return *instance; + return instance_ref; } template <typename T> -void ComponentManager::delete_components_by_id(uint32_t id) { +void ComponentManager::delete_components_by_id(game_object_id_t id) { using namespace std; // Determine the type of T (this is used as the key of the unordered_map<>) type_index type = typeid(T); // Find the type (in the unordered_map<>) - if (components.find(type) != components.end()) { + if (this->components.find(type) != this->components.end()) { // Get the correct vector<> vector<vector<unique_ptr<Component>>> & component_array - = components[type]; + = this->components[type]; // Make sure that the id (that we are looking for) is within the boundaries of the vector<> if (id < component_array.size()) { @@ -63,14 +77,14 @@ void ComponentManager::delete_components() { // Determine the type of T (this is used as the key of the unordered_map<>) std::type_index type = typeid(T); - if (components.find(type) == components.end()) return; + if (this->components.find(type) == this->components.end()) return; - components[type].clear(); + this->components[type].clear(); } template <typename T> std::vector<std::reference_wrapper<T>> -ComponentManager::get_components_by_id(uint32_t id) const { +ComponentManager::get_components_by_id(game_object_id_t id) const { using namespace std; // Determine the type of T (this is used as the key of the unordered_map<>) @@ -79,11 +93,12 @@ ComponentManager::get_components_by_id(uint32_t id) const { // Create an empty vector<> vector<reference_wrapper<T>> component_vector; - if (components.find(type) == components.end()) return component_vector; + if (this->components.find(type) == this->components.end()) + return component_vector; // Get the correct vector<> const vector<vector<unique_ptr<Component>>> & component_array - = components.at(type); + = this->components.at(type); // Make sure that the id (that we are looking for) is within the boundaries of the vector<> if (id >= component_array.size()) return component_vector; @@ -112,15 +127,14 @@ ComponentManager::get_components_by_type() const { // Create an empty vector<> vector<reference_wrapper<T>> component_vector; - // Set the id to 0 (the id will also be stored in the returned vector<>) - // uint32_t id = 0; // Find the type (in the unordered_map<>) - if (components.find(type) == components.end()) return component_vector; + if (this->components.find(type) == this->components.end()) + return component_vector; // Get the correct vector<> const vector<vector<unique_ptr<Component>>> & component_array - = components.at(type); + = this->components.at(type); // Loop through the whole vector<> for (const vector<unique_ptr<Component>> & component : component_array) { @@ -132,12 +146,9 @@ ComponentManager::get_components_by_type() const { // Ensure that the cast was successful if (casted_component == nullptr) continue; - // Pair the dereferenced raw pointer and the id and add it to the vector<> + // Add the dereferenced raw pointer to the vector<> component_vector.emplace_back(ref(*casted_component)); } - - // Increase the id (the id will also be stored in the returned vector<>) - //++id; } // Return the vector<> diff --git a/src/crepe/api/AudioSource.h b/src/crepe/api/AudioSource.h index 42add50..1e24ae8 100644 --- a/src/crepe/api/AudioSource.h +++ b/src/crepe/api/AudioSource.h @@ -10,7 +10,7 @@ namespace crepe { class Sound; //! Audio source component -class AudioSource : Component { +class AudioSource : public Component { public: AudioSource(std::unique_ptr<Asset> audio_clip); virtual ~AudioSource() = default; diff --git a/src/crepe/api/BehaviorScript.h b/src/crepe/api/BehaviorScript.h index 21638f4..6b1fec7 100644 --- a/src/crepe/api/BehaviorScript.h +++ b/src/crepe/api/BehaviorScript.h @@ -5,12 +5,9 @@ #include "../Component.h" namespace crepe { + class ScriptSystem; class ComponentManager; -} // namespace crepe - -namespace crepe { - class Script; class BehaviorScript : public Component { diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt index f55bd9e..3b20142 100644 --- a/src/crepe/api/CMakeLists.txt +++ b/src/crepe/api/CMakeLists.txt @@ -4,7 +4,6 @@ target_sources(crepe PUBLIC Script.cpp GameObject.cpp Rigidbody.cpp - Force.cpp ParticleEmitter.cpp Transform.cpp Color.cpp @@ -13,6 +12,10 @@ target_sources(crepe PUBLIC Sprite.cpp SaveManager.cpp Config.cpp + Metadata.cpp + Scene.cpp + SceneManager.cpp + Vector2.cpp ) target_sources(crepe PUBLIC FILE_SET HEADERS FILES @@ -25,10 +28,14 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES GameObject.hpp Rigidbody.h Sprite.h - Point.h + Vector2.h Color.h Texture.h AssetManager.h AssetManager.hpp SaveManager.h + Scene.h + Metadata.h + SceneManager.h + SceneManager.hpp ) diff --git a/src/crepe/api/CircleCollider.h b/src/crepe/api/CircleCollider.h index 931b012..caa7e43 100644 --- a/src/crepe/api/CircleCollider.h +++ b/src/crepe/api/CircleCollider.h @@ -5,7 +5,7 @@ namespace crepe { class CircleCollider : public Collider { public: - CircleCollider(uint32_t game_object_id, int radius) + CircleCollider(game_object_id_t game_object_id, int radius) : Collider(game_object_id), radius(radius) {} int radius; }; diff --git a/src/crepe/api/Config.h b/src/crepe/api/Config.h index bbcca87..56e3af5 100644 --- a/src/crepe/api/Config.h +++ b/src/crepe/api/Config.h @@ -47,6 +47,16 @@ public: */ std::string location = "save.crepe.db"; } savemgr; + + //! physics-related settings + struct { + /** + * \brief gravity value of physics system + * + * Gravity value of game. + */ + double gravity = 1; + } physics; }; } // namespace crepe diff --git a/src/crepe/api/Force.cpp b/src/crepe/api/Force.cpp deleted file mode 100644 index 3c33ad3..0000000 --- a/src/crepe/api/Force.cpp +++ /dev/null @@ -1,21 +0,0 @@ -#include <cmath> - -#include "Force.h" - -namespace crepe { - -Force::Force(uint32_t game_object_id, uint32_t magnitude, uint32_t direction) - : Component(game_object_id) { - // TODO: A standard angle unit should be established for the entire engine - // and assumed to be the default everywhere. Only conversion functions should - // explicitly contain the unit (i.e. `deg_to_rad()` & `rad_to_deg()`) - - // Convert direction from degrees to radians - float radian_direction = static_cast<float>(direction) * (M_PI / 180.0f); - force_x = static_cast<int32_t>( - std::round(magnitude * std::cos(radian_direction))); - force_y = static_cast<int32_t>( - std::round(magnitude * std::sin(radian_direction))); -} - -} // namespace crepe diff --git a/src/crepe/api/Force.h b/src/crepe/api/Force.h deleted file mode 100644 index c08a8b9..0000000 --- a/src/crepe/api/Force.h +++ /dev/null @@ -1,17 +0,0 @@ -#pragma once - -#include <cstdint> - -#include "../Component.h" - -namespace crepe { - -class Force : public Component { -public: - Force(uint32_t game_object_id, uint32_t magnitude, uint32_t direction); - - int32_t force_x; - int32_t force_y; -}; - -} // namespace crepe diff --git a/src/crepe/api/GameObject.cpp b/src/crepe/api/GameObject.cpp index 445a60d..d252e77 100644 --- a/src/crepe/api/GameObject.cpp +++ b/src/crepe/api/GameObject.cpp @@ -1,7 +1,31 @@ +#include "api/Transform.h" + #include "GameObject.h" +#include "Metadata.h" using namespace crepe; using namespace std; -GameObject::GameObject(uint32_t id, string name, string tag, int layer) - : id(id), name(name), tag(tag), active(true), layer(layer) {} +GameObject::GameObject(game_object_id_t id, const std::string & name, + const std::string & tag, const Vector2 & position, + double rotation, double scale) + : id(id) { + // Add Transform and Metadata components + ComponentManager & mgr = ComponentManager::get_instance(); + mgr.add_component<Transform>(this->id, position, rotation, scale); + mgr.add_component<Metadata>(this->id, name, tag); +} + +void GameObject::set_parent(const GameObject & parent) { + ComponentManager & mgr = ComponentManager::get_instance(); + + // Set parent on own Metadata component + vector<reference_wrapper<Metadata>> this_metadata + = mgr.get_components_by_id<Metadata>(this->id); + this_metadata.at(0).get().parent = parent.id; + + // Add own id to children list of parent's Metadata component + vector<reference_wrapper<Metadata>> parent_metadata + = mgr.get_components_by_id<Metadata>(parent.id); + parent_metadata.at(0).get().children.push_back(this->id); +} diff --git a/src/crepe/api/GameObject.h b/src/crepe/api/GameObject.h index b5d6399..d703730 100644 --- a/src/crepe/api/GameObject.h +++ b/src/crepe/api/GameObject.h @@ -1,22 +1,63 @@ #pragma once -#include <cstdint> #include <string> +#include "types.h" + namespace crepe { +class Vector2; + +/** + * \brief Represents a GameObject + * + * This class represents a GameObject. The GameObject class is only used + * as an interface for the game programmer. The actual implementation is + * done in the ComponentManager. + */ class GameObject { public: - GameObject(uint32_t id, std::string name, std::string tag, int layer); - + /** + * This constructor creates a new GameObject. It creates a new + * Transform and Metadata component and adds them to the ComponentManager. + * + * \param id The id of the GameObject + * \param name The name of the GameObject + * \param tag The tag of the GameObject + * \param position The position of the GameObject + * \param rotation The rotation of the GameObject + * \param scale The scale of the GameObject + */ + GameObject(game_object_id_t id, const std::string & name, + const std::string & tag, const Vector2 & position, + double rotation, double scale); + /** + * \brief Set the parent of this GameObject + * + * This method sets the parent of this GameObject. It sets the parent + * in the Metadata component of this GameObject and adds this GameObject + * to the children list of the parent GameObject. + * + * \param parent The parent GameObject + */ + void set_parent(const GameObject & parent); + /** + * \brief Add a component to the GameObject + * + * This method adds a component to the GameObject. It forwards the + * arguments to the ComponentManager. + * + * \tparam T The type of the component + * \tparam Args The types of the arguments + * \param args The arguments to create the component + * \return The created component + */ template <typename T, typename... Args> T & add_component(Args &&... args); - uint32_t id; - std::string name; - std::string tag; - bool active; - int layer; +public: + //! The id of the GameObject + const game_object_id_t id; }; } // namespace crepe diff --git a/src/crepe/api/GameObject.hpp b/src/crepe/api/GameObject.hpp index 77cf40e..bfba7fe 100644 --- a/src/crepe/api/GameObject.hpp +++ b/src/crepe/api/GameObject.hpp @@ -8,7 +8,7 @@ namespace crepe { template <typename T, typename... Args> T & GameObject::add_component(Args &&... args) { - auto & mgr = ComponentManager::get_instance(); + ComponentManager & mgr = ComponentManager::get_instance(); return mgr.add_component<T>(this->id, std::forward<Args>(args)...); } diff --git a/src/crepe/api/Metadata.cpp b/src/crepe/api/Metadata.cpp new file mode 100644 index 0000000..76f11d7 --- /dev/null +++ b/src/crepe/api/Metadata.cpp @@ -0,0 +1,7 @@ +#include "Metadata.h" + +using namespace crepe; +using namespace std; + +Metadata::Metadata(game_object_id_t id, const string & name, const string & tag) + : Component(id), name(name), tag(tag) {} diff --git a/src/crepe/api/Metadata.h b/src/crepe/api/Metadata.h new file mode 100644 index 0000000..c61e006 --- /dev/null +++ b/src/crepe/api/Metadata.h @@ -0,0 +1,43 @@ +#pragma once + +#include <string> +#include <vector> + +#include "../Component.h" + +namespace crepe { + +/** + * \brief Metadata component + * + * This class represents the Metadata component. It stores the name, tag, parent + * and children of a GameObject. + */ +class Metadata : public Component { +public: + /** + * \param game_object_id The id of the GameObject this component belongs to + * \param name The name of the GameObject + * \param tag The tag of the GameObject + */ + Metadata(game_object_id_t id, const std::string & name, + const std::string & tag); + /** + * \brief Get the maximum number of instances for this component + * + * \return The maximum number of instances for this component + */ + virtual int get_instances_max() const { return 1; } + +public: + //! The name of the GameObject + const std::string name; + //! The tag of the GameObject + const std::string tag; + //! The id of the parent GameObject (-1 if no parent) + game_object_id_t parent = -1; + //! The ids of the children GameObjects + std::vector<game_object_id_t> children; +}; + +} // namespace crepe diff --git a/src/crepe/api/ParticleEmitter.cpp b/src/crepe/api/ParticleEmitter.cpp index 0b3a9ee..3b2e2f2 100644 --- a/src/crepe/api/ParticleEmitter.cpp +++ b/src/crepe/api/ParticleEmitter.cpp @@ -6,15 +6,14 @@ using namespace crepe; -ParticleEmitter::ParticleEmitter(uint32_t game_object_id, - uint32_t max_particles, uint32_t emission_rate, - uint32_t speed, uint32_t speed_offset, - uint32_t angle, uint32_t angleOffset, - float begin_lifespan, float end_lifespan) - : Component(game_object_id), max_particles(max_particles), - emission_rate(emission_rate), speed(speed), speed_offset(speed_offset), - position{0, 0}, begin_lifespan(begin_lifespan), - end_lifespan(end_lifespan) { +ParticleEmitter::ParticleEmitter(game_object_id_t id, uint32_t max_particles, + uint32_t emission_rate, uint32_t speed, + uint32_t speed_offset, uint32_t angle, + uint32_t angleOffset, float begin_lifespan, + float end_lifespan) + : Component(id), max_particles(max_particles), emission_rate(emission_rate), + speed(speed), speed_offset(speed_offset), position{0, 0}, + begin_lifespan(begin_lifespan), end_lifespan(end_lifespan) { std::srand( static_cast<uint32_t>(std::time(nullptr))); // initialize random seed std::cout << "Create emitter" << std::endl; diff --git a/src/crepe/api/ParticleEmitter.h b/src/crepe/api/ParticleEmitter.h index 2e2e95b..5939723 100644 --- a/src/crepe/api/ParticleEmitter.h +++ b/src/crepe/api/ParticleEmitter.h @@ -10,7 +10,7 @@ namespace crepe { class ParticleEmitter : public Component { public: - ParticleEmitter(uint32_t game_object_id, uint32_t max_particles, + ParticleEmitter(game_object_id_t id, uint32_t max_particles, uint32_t emission_rate, uint32_t speed, uint32_t speed_offset, uint32_t angle, uint32_t angleOffset, float begin_lifespan, float end_lifespan); diff --git a/src/crepe/api/Point.h b/src/crepe/api/Point.h deleted file mode 100644 index 575d624..0000000 --- a/src/crepe/api/Point.h +++ /dev/null @@ -1,11 +0,0 @@ -#pragma once - -namespace crepe { - -class Point { -public: - double x; - double y; -}; - -} // namespace crepe diff --git a/src/crepe/api/Rigidbody.cpp b/src/crepe/api/Rigidbody.cpp index 0a6262a..cbf1325 100644 --- a/src/crepe/api/Rigidbody.cpp +++ b/src/crepe/api/Rigidbody.cpp @@ -2,7 +2,13 @@ using namespace crepe; -Rigidbody::Rigidbody(uint32_t game_object_id, int mass, int gravity_scale, - BodyType bodyType) - : Component(game_object_id), mass(mass), gravity_scale(gravity_scale), - body_type(bodyType) {} +crepe::Rigidbody::Rigidbody(uint32_t game_object_id, const Data & data) + : Component(game_object_id), data(data) {} + +void crepe::Rigidbody::add_force_linear(const Vector2 & force) { + this->data.linear_velocity += force; +} + +void crepe::Rigidbody::add_force_angular(double force) { + this->data.angular_velocity += force; +} diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h index 518ed94..68481f4 100644 --- a/src/crepe/api/Rigidbody.h +++ b/src/crepe/api/Rigidbody.h @@ -4,27 +4,101 @@ #include "../Component.h" -namespace crepe { +#include "Vector2.h" -// FIXME: can't this enum be defined inside the class declaration of Rigidbody? -enum class BodyType { - //! Does not move (e.g. walls, ground ...) - STATIC, - //! Moves and responds to forces (e.g. player, physics objects ...) - DYNAMIC, - //! Moves but does not respond to forces (e.g. moving platforms ...) - KINEMATIC, -}; +namespace crepe { +/** + * \brief Rigidbody class + * + * This class is used by the physics sytem and collision system. + * It configures how to system interact with the gameobject for movement and collisions. + */ class Rigidbody : public Component { public: - Rigidbody(uint32_t game_object_id, int mass, int gravity_scale, - BodyType body_type); - int32_t velocity_x; - int32_t velocity_y; - int mass; - int gravity_scale; - BodyType body_type; + /** + * \brief BodyType enum + * + * This enum provides three bodytypes the physics sytem and collision system use. + */ + enum class BodyType { + //! Does not move (e.g. walls, ground ...) + STATIC, + //! Moves and responds to forces (e.g. player, physics objects ...) + DYNAMIC, + //! Moves but does not respond to forces (e.g. moving platforms ...) + KINEMATIC, + }; + /** + * \brief PhysicsConstraints to constrain movement + * + * This struct configures the movement constraint for this object. + * If a constraint is enabled the systems will not move the object. + */ + struct PhysicsConstraints { + //! X constraint + bool x = false; + //! Y constraint + bool y = false; + //! rotation constraint + bool rotation = false; + }; + +public: + /** + * \brief struct for Rigidbody data + * + * This struct holds the data for the Rigidbody. + */ + struct Data { + //! objects mass + double mass = 0.0; + //! gravtiy scale + double gravity_scale = 0.0; + //! Changes if physics apply + BodyType body_type = BodyType::DYNAMIC; + //! linear velocity of object + Vector2 linear_velocity; + //! maximum linear velocity of object + Vector2 max_linear_velocity; + //! linear damping of object + Vector2 linear_damping; + //! angular velocity of object + double angular_velocity = 0.0; + //! max angular velocity of object + double max_angular_velocity = 0.0; + //! angular damping of object + double angular_damping = 0.0; + //! movements constraints of object + PhysicsConstraints constraints; + //! if gravity applies + bool use_gravity = true; + //! if object bounces + bool bounce = false; + }; + +public: + /** + * \param game_object_id id of the gameobject the rigibody is added to. + * \param data struct to configure the rigidbody. + */ + Rigidbody(uint32_t game_object_id, const Data & data); + //! struct to hold data of rigidbody + Data data; + +public: + /** + * \brief add a linear force to the Rigidbody. + * + * \param force Vector2 that is added to the linear force. + */ + void add_force_linear(const Vector2 & force); + /** + * \brief add a angular force to the Rigidbody. + * + * \param force Vector2 that is added to the angular force. + */ + void add_force_angular(double force); }; } // namespace crepe diff --git a/src/crepe/api/Scene.cpp b/src/crepe/api/Scene.cpp new file mode 100644 index 0000000..933edf4 --- /dev/null +++ b/src/crepe/api/Scene.cpp @@ -0,0 +1,5 @@ +#include "Scene.h" + +using namespace crepe; + +Scene::Scene(const std::string & name) : name(name) {} diff --git a/src/crepe/api/Scene.h b/src/crepe/api/Scene.h new file mode 100644 index 0000000..f8bcc3d --- /dev/null +++ b/src/crepe/api/Scene.h @@ -0,0 +1,17 @@ +#pragma once + +#include <string> + +namespace crepe { + +class Scene { +public: + Scene(const std::string & name); + virtual ~Scene() = default; + virtual void load_scene() = 0; + +public: + std::string name; +}; + +} // namespace crepe diff --git a/src/crepe/api/SceneManager.cpp b/src/crepe/api/SceneManager.cpp new file mode 100644 index 0000000..dfed6ee --- /dev/null +++ b/src/crepe/api/SceneManager.cpp @@ -0,0 +1,38 @@ +#include <algorithm> +#include <memory> + +#include "../ComponentManager.h" + +#include "SceneManager.h" + +using namespace crepe; +using namespace std; + +SceneManager & SceneManager::get_instance() { + static SceneManager instance; + return instance; +} + +void SceneManager::set_next_scene(const string & name) { next_scene = name; } + +void SceneManager::load_next_scene() { + // next scene not set + if (this->next_scene.empty()) return; + + auto it + = find_if(this->scenes.begin(), this->scenes.end(), + [&next_scene = this->next_scene](unique_ptr<Scene> & scene) { + return scene->name == next_scene; + }); + + // next scene not found + if (it == this->scenes.end()) return; + unique_ptr<Scene> & scene = *it; + + // Delete all components of the current scene + ComponentManager & mgr = ComponentManager::get_instance(); + mgr.delete_all_components(); + + // Load the new scene + scene->load_scene(); +} diff --git a/src/crepe/api/SceneManager.h b/src/crepe/api/SceneManager.h new file mode 100644 index 0000000..1e0e670 --- /dev/null +++ b/src/crepe/api/SceneManager.h @@ -0,0 +1,50 @@ +#pragma once + +#include <memory> +#include <queue> +#include <vector> + +#include "Scene.h" + +namespace crepe { + +class SceneManager { +public: + // Singleton + static SceneManager & get_instance(); + SceneManager(const SceneManager &) = delete; + SceneManager(SceneManager &&) = delete; + SceneManager & operator=(const SceneManager &) = delete; + SceneManager & operator=(SceneManager &&) = delete; + +public: + /** + * \brief Add a new concrete scene to the scene manager + * + * \tparam T Type of concrete scene + * \param name Name of new scene + */ + template <typename T> + void add_scene(const std::string & name); + /** + * \brief Set the next scene + * + * This scene will be loaded at the end of the frame + * + * \param name Name of the next scene + */ + void set_next_scene(const std::string & name); + //! Load a new scene (if there is one) + void load_next_scene(); + +private: + SceneManager() = default; + +private: + std::vector<std::unique_ptr<Scene>> scenes; + std::string next_scene; +}; + +} // namespace crepe + +#include "SceneManager.hpp" diff --git a/src/crepe/api/SceneManager.hpp b/src/crepe/api/SceneManager.hpp new file mode 100644 index 0000000..8bad7b2 --- /dev/null +++ b/src/crepe/api/SceneManager.hpp @@ -0,0 +1,18 @@ +#include "SceneManager.h" + +namespace crepe { + +template <typename T> +void SceneManager::add_scene(const std::string & name) { + static_assert(std::is_base_of<Scene, T>::value, + "T must be derived from Scene"); + + scenes.emplace_back(make_unique<T>(name)); + + // The first scene added, is the one that will be loaded at the beginning + if (next_scene.empty()) { + next_scene = name; + } +} + +} // namespace crepe diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp index 3dd44f2..d3465c7 100644 --- a/src/crepe/api/Sprite.cpp +++ b/src/crepe/api/Sprite.cpp @@ -10,8 +10,8 @@ using namespace std; using namespace crepe; -Sprite::Sprite(uint32_t id, shared_ptr<Texture> image, const Color & color, - const FlipSettings & flip) +Sprite::Sprite(game_object_id_t id, shared_ptr<Texture> image, + const Color & color, const FlipSettings & flip) : Component(id), color(color), flip(flip), sprite_image(image) { dbg_trace(); } diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h index bdb4da9..00dcb27 100644 --- a/src/crepe/api/Sprite.h +++ b/src/crepe/api/Sprite.h @@ -12,14 +12,14 @@ namespace crepe { struct FlipSettings { - bool flip_x = 1; - bool flip_y = 1; + bool flip_x = true; + bool flip_y = true; }; class Sprite : public Component { public: - Sprite(uint32_t game_id, std::shared_ptr<Texture> image, + Sprite(game_object_id_t id, std::shared_ptr<Texture> image, const Color & color, const FlipSettings & flip); ~Sprite(); std::shared_ptr<Texture> sprite_image; diff --git a/src/crepe/api/Transform.cpp b/src/crepe/api/Transform.cpp index 70b16bd..a244bc5 100644 --- a/src/crepe/api/Transform.cpp +++ b/src/crepe/api/Transform.cpp @@ -1,16 +1,11 @@ -#include <cstdint> - -#include "api/Point.h" #include "util/log.h" -#include "Component.h" #include "Transform.h" using namespace crepe; -Transform::Transform(uint32_t game_id, const Point & point, double rot, - double scale) - : Component(game_id), position(point), rotation(rot), scale(scale) { +Transform::Transform(game_object_id_t id, const Vector2 & point, + double rotation, double scale) + : Component(id), position(point), rotation(rotation), scale(scale) { dbg_trace(); } -Transform::~Transform() { dbg_trace(); } diff --git a/src/crepe/api/Transform.h b/src/crepe/api/Transform.h index d416088..d7a5b8a 100644 --- a/src/crepe/api/Transform.h +++ b/src/crepe/api/Transform.h @@ -1,23 +1,37 @@ #pragma once -#include <cstdint> - -#include "api/Point.h" +#include "api/Vector2.h" #include "Component.h" namespace crepe { +/** + * \brief Transform component + * + * This class represents the Transform component. It stores the position, + * rotation and scale of a GameObject. + */ class Transform : public Component { - // FIXME: What's the difference between the `Point` and `Position` - // classes/structs? How about we replace both with a universal `Vec2` that - // works similar (or the same) as those found in GLSL? +public: + /** + * \param id The id of the GameObject this component belongs to + * \param point The position of the GameObject + * \param rotation The rotation of the GameObject + * \param scale The scale of the GameObject + */ + Transform(game_object_id_t id, const Vector2 & point, double rotation, + double scale); + /** + * \brief Get the maximum number of instances for this component + * + * \return The maximum number of instances for this component + */ + virtual int get_instances_max() const { return 1; } public: - Transform(uint32_t id, const Point &, double, double); - ~Transform(); //! Translation (shift) - Point position; + Vector2 position; //! Rotation, in radians double rotation; //! Multiplication factor diff --git a/src/crepe/api/Vector2.cpp b/src/crepe/api/Vector2.cpp new file mode 100644 index 0000000..09bb59b --- /dev/null +++ b/src/crepe/api/Vector2.cpp @@ -0,0 +1,57 @@ +#include "Vector2.h" + +namespace crepe { + +// Constructor with initial values +Vector2::Vector2(float x, float y) : x(x), y(y) {} + +// Subtracts another vector from this vector and returns the result. +Vector2 Vector2::operator-(const Vector2 & other) const { + return {x - other.x, y - other.y}; +} + +// Adds another vector to this vector and returns the result. +Vector2 Vector2::operator+(const Vector2 & other) const { + return {x + other.x, y + other.y}; +} + +// Multiplies this vector by a scalar and returns the result. +Vector2 Vector2::operator*(float scalar) const { + return {x * scalar, y * scalar}; +} + +// Multiplies this vector by another vector element-wise and updates this vector. +Vector2 & Vector2::operator*=(const Vector2 & other) { + x *= other.x; + y *= other.y; + return *this; +} + +// Adds another vector to this vector and updates this vector. +Vector2 & Vector2::operator+=(const Vector2 & other) { + x += other.x; + y += other.y; + return *this; +} + +// Adds a scalar value to both components of this vector and updates this vector. +Vector2 & Vector2::operator+=(float other) { + x += other; + y += other; + return *this; +} + +// Returns the negation of this vector. +Vector2 Vector2::operator-() const { return {-x, -y}; } + +// Checks if this vector is equal to another vector. +bool Vector2::operator==(const Vector2 & other) const { + return x == other.x && y == other.y; +} + +// Checks if this vector is not equal to another vector. +bool Vector2::operator!=(const Vector2 & other) const { + return !(*this == other); +} + +} // namespace crepe diff --git a/src/crepe/api/Vector2.h b/src/crepe/api/Vector2.h new file mode 100644 index 0000000..741951b --- /dev/null +++ b/src/crepe/api/Vector2.h @@ -0,0 +1,47 @@ +#pragma once + +namespace crepe { + +//! Vector2 class +class Vector2 { +public: + //! X component of the vector + float x; + //! Y component of the vector + float y; + + //! Default constructor + Vector2() = default; + + //! Constructor with initial values + Vector2(float x, float y); + + //! Subtracts another vector from this vector and returns the result. + Vector2 operator-(const Vector2 & other) const; + + //! Adds another vector to this vector and returns the result. + Vector2 operator+(const Vector2 & other) const; + + //! Multiplies this vector by a scalar and returns the result. + Vector2 operator*(float scalar) const; + + //! Multiplies this vector by another vector element-wise and updates this vector. + Vector2 & operator*=(const Vector2 & other); + + //! Adds another vector to this vector and updates this vector. + Vector2 & operator+=(const Vector2 & other); + + //! Adds a scalar value to both components of this vector and updates this vector. + Vector2 & operator+=(float other); + + //! Returns the negation of this vector. + Vector2 operator-() const; + + //! Checks if this vector is equal to another vector. + bool operator==(const Vector2 & other) const; + + //! Checks if this vector is not equal to another vector. + bool operator!=(const Vector2 & other) const; +}; + +} // namespace crepe diff --git a/src/crepe/facade/CMakeLists.txt b/src/crepe/facade/CMakeLists.txt index bb52e7a..4cc53bc 100644 --- a/src/crepe/facade/CMakeLists.txt +++ b/src/crepe/facade/CMakeLists.txt @@ -1,7 +1,6 @@ target_sources(crepe PUBLIC Sound.cpp SoundContext.cpp - SDLApp.cpp SDLContext.cpp DB.cpp ) @@ -10,7 +9,6 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES Sound.h SoundContext.h SDLContext.h - SDLContext.h DB.h ) diff --git a/src/crepe/facade/SDLApp.cpp b/src/crepe/facade/SDLApp.cpp deleted file mode 100644 index c6ddeaa..0000000 --- a/src/crepe/facade/SDLApp.cpp +++ /dev/null @@ -1,71 +0,0 @@ -#include <iostream> - -#include "SDLApp.h" - -SDLApp::SDLApp(int window_width, int window_height) - : window_width(window_width), window_height(window_height), window(nullptr), - renderer(nullptr) {} - -// FIXME: why is there clean_up and ~SDLApp? -SDLApp::~SDLApp() { clean_up(); } - -bool SDLApp::initialize() { - if (SDL_Init(SDL_INIT_VIDEO) != 0) { - // FIXME: throw exception - std::cerr << "SDL Initialization Error: " << SDL_GetError() - << std::endl; - return false; - } - - window = SDL_CreateWindow("Particle System", SDL_WINDOWPOS_CENTERED, - SDL_WINDOWPOS_CENTERED, window_width, - window_height, SDL_WINDOW_SHOWN); - if (!window) { - // FIXME: throw exception - std::cerr << "Window Creation Error: " << SDL_GetError() << std::endl; - return false; - } - - renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED); - if (!renderer) { - // FIXME: throw exception - std::cerr << "Renderer Creation Error: " << SDL_GetError() << std::endl; - return false; - } - - return true; -} - -void SDLApp::handle_events(bool & running) { - SDL_Event event; - while (SDL_PollEvent(&event)) { - if (event.type == SDL_QUIT) { - running = false; - } - } -} - -void SDLApp::clear_screen() { - SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255); - SDL_RenderClear(renderer); -} - -void SDLApp::present_screen() { SDL_RenderPresent(renderer); } - -void SDLApp::draw_square(int x, int y, int size) { - SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255); - SDL_Rect rect = {x, y, size, size}; - SDL_RenderFillRect(renderer, &rect); -} - -SDL_Texture * square_texture = nullptr; // Load this with an image or create it - -void SDLApp::clean_up() { - if (renderer) { - SDL_DestroyRenderer(renderer); - } - if (window) { - SDL_DestroyWindow(window); - } - SDL_Quit(); -} diff --git a/src/crepe/facade/SDLApp.h b/src/crepe/facade/SDLApp.h deleted file mode 100644 index 6d8f3f4..0000000 --- a/src/crepe/facade/SDLApp.h +++ /dev/null @@ -1,26 +0,0 @@ -#pragma once - -#include <SDL2/SDL.h> - -#include "../api/ParticleEmitter.h" - -class SDLApp { -public: - SDLApp(int window_width, int window_height); - ~SDLApp(); - - bool initialize(); - void handle_events(bool & running); - void clear_screen(); - void present_screen(); - void draw_square(int x, int y, int size); - void clean_up(); - void draw_particles(const std::vector<crepe::ParticleEmitter> & emitters); - void draw_multiple_squares(const std::vector<SDL_Rect> & squares); - -private: - int window_width; - int window_height; - SDL_Window * window; - SDL_Renderer * renderer; -}; diff --git a/src/crepe/system/PhysicsSystem.cpp b/src/crepe/system/PhysicsSystem.cpp index cea8062..eb54ad3 100644 --- a/src/crepe/system/PhysicsSystem.cpp +++ b/src/crepe/system/PhysicsSystem.cpp @@ -1,16 +1,15 @@ -#include <iostream> +#include <cmath> #include "../ComponentManager.h" -#include "../api/Force.h" +#include "../api/Config.h" #include "../api/Rigidbody.h" #include "../api/Transform.h" +#include "../api/Vector2.h" #include "PhysicsSystem.h" using namespace crepe; -PhysicsSystem::PhysicsSystem() {} - void PhysicsSystem::update() { ComponentManager & mgr = ComponentManager::get_instance(); std::vector<std::reference_wrapper<Rigidbody>> rigidbodies @@ -18,41 +17,86 @@ void PhysicsSystem::update() { std::vector<std::reference_wrapper<Transform>> transforms = mgr.get_components_by_type<Transform>(); + double gravity = Config::get_instance().physics.gravity; for (Rigidbody & rigidbody : rigidbodies) { + if (!rigidbody.active) continue; - switch (rigidbody.body_type) { - case BodyType::DYNAMIC: + switch (rigidbody.data.body_type) { + case Rigidbody::BodyType::DYNAMIC: for (Transform & transform : transforms) { if (transform.game_object_id == rigidbody.game_object_id) { - rigidbody.velocity_x = 0; - rigidbody.velocity_y = 0; - std::vector<std::reference_wrapper<Force>> forces - = mgr.get_components_by_id<Force>( - rigidbody.game_object_id); - rigidbody.velocity_y - += rigidbody.gravity_scale * 1 * rigidbody.mass; - - for (Force & force : forces) { - rigidbody.velocity_x += force.force_x; - rigidbody.velocity_y += force.force_y; - } - - std::cout << "before transform.postion.x " - << transform.position.x << std::endl; - std::cout << "before transform.postion.y " - << transform.position.y << std::endl; - transform.position.x += rigidbody.velocity_x; - transform.position.y += rigidbody.velocity_y; - std::cout << "after transform.postion.x " - << transform.position.x << std::endl; - std::cout << "after transform.postion.y " - << transform.position.y << std::endl; + + // Add gravity + if (rigidbody.data.use_gravity) { + rigidbody.data.linear_velocity.y + += (rigidbody.data.mass + * rigidbody.data.gravity_scale * gravity); + } + // Add damping + if (rigidbody.data.angular_damping != 0) { + rigidbody.data.angular_velocity + *= rigidbody.data.angular_damping; + } + if (rigidbody.data.linear_damping != Vector2{0, 0}) { + rigidbody.data.linear_velocity + *= rigidbody.data.linear_damping; + } + + // Max velocity check + if (rigidbody.data.angular_velocity + > rigidbody.data.max_angular_velocity) { + rigidbody.data.angular_velocity + = rigidbody.data.max_angular_velocity; + } else if (rigidbody.data.angular_velocity + < -rigidbody.data.max_angular_velocity) { + rigidbody.data.angular_velocity + = -rigidbody.data.max_angular_velocity; + } + + if (rigidbody.data.linear_velocity.x + > rigidbody.data.max_linear_velocity.x) { + rigidbody.data.linear_velocity.x + = rigidbody.data.max_linear_velocity.x; + } else if (rigidbody.data.linear_velocity.x + < -rigidbody.data.max_linear_velocity.x) { + rigidbody.data.linear_velocity.x + = -rigidbody.data.max_linear_velocity.x; + } + + if (rigidbody.data.linear_velocity.y + > rigidbody.data.max_linear_velocity.y) { + rigidbody.data.linear_velocity.y + = rigidbody.data.max_linear_velocity.y; + } else if (rigidbody.data.linear_velocity.y + < -rigidbody.data.max_linear_velocity.y) { + rigidbody.data.linear_velocity.y + = -rigidbody.data.max_linear_velocity.y; + } + + // Move object + if (!rigidbody.data.constraints.rotation) { + transform.rotation + += rigidbody.data.angular_velocity; + transform.rotation + = std::fmod(transform.rotation, 360.0); + if (transform.rotation < 0) { + transform.rotation += 360.0; + } + } + if (!rigidbody.data.constraints.x) { + transform.position.x + += rigidbody.data.linear_velocity.x; + } + if (!rigidbody.data.constraints.y) { + transform.position.y + += rigidbody.data.linear_velocity.y; + } } } break; - case BodyType::KINEMATIC: + case Rigidbody::BodyType::KINEMATIC: break; //(scripts) - case BodyType::STATIC: + case Rigidbody::BodyType::STATIC: break; //(unmoveable objects) default: break; diff --git a/src/crepe/system/PhysicsSystem.h b/src/crepe/system/PhysicsSystem.h index 33b4072..cc13b70 100644 --- a/src/crepe/system/PhysicsSystem.h +++ b/src/crepe/system/PhysicsSystem.h @@ -1,10 +1,23 @@ #pragma once namespace crepe { - +/** + * \brief System that controls all physics + * + * This class is a physics system that uses a rigidbody and transform + * to add physics to a game object. + */ class PhysicsSystem { public: - PhysicsSystem(); + /** + * Constructor is default + */ + PhysicsSystem() = default; + /** + * \brief updates the physics system. + * + * It calculates new velocties and changes the postion in the transform. + */ void update(); }; diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp index 96c94e9..5a07cc2 100644 --- a/src/crepe/system/RenderSystem.cpp +++ b/src/crepe/system/RenderSystem.cpp @@ -2,9 +2,9 @@ #include <vector> #include "../ComponentManager.h" -#include "../facade/SDLContext.h" #include "../api/Sprite.h" #include "../api/Transform.h" +#include "../facade/SDLContext.h" #include "../util/log.h" #include "RenderSystem.h" diff --git a/src/crepe/system/ScriptSystem.cpp b/src/crepe/system/ScriptSystem.cpp index f1fae4d..f2673e7 100644 --- a/src/crepe/system/ScriptSystem.cpp +++ b/src/crepe/system/ScriptSystem.cpp @@ -12,14 +12,6 @@ using namespace std; using namespace crepe; -ScriptSystem::ScriptSystem() { dbg_trace(); } -ScriptSystem::~ScriptSystem() { dbg_trace(); } - -ScriptSystem & ScriptSystem::get_instance() { - static ScriptSystem instance; - return instance; -} - void ScriptSystem::update() { using namespace std; dbg_trace(); diff --git a/src/crepe/system/ScriptSystem.h b/src/crepe/system/ScriptSystem.h index 32e793c..4fa6141 100644 --- a/src/crepe/system/ScriptSystem.h +++ b/src/crepe/system/ScriptSystem.h @@ -10,14 +10,9 @@ class Script; class ScriptSystem : public System { public: - static ScriptSystem & get_instance(); void update(); private: - ScriptSystem(); - ~ScriptSystem(); - -private: // TODO: to forward_list<reference_wrapper> std::forward_list<Script *> get_scripts(); }; diff --git a/src/crepe/system/System.h b/src/crepe/system/System.h index ecbb7f5..3b81bef 100644 --- a/src/crepe/system/System.h +++ b/src/crepe/system/System.h @@ -4,19 +4,11 @@ namespace crepe { class System { public: - static System & get_instance(); virtual void update() = 0; -protected: - System() {}; - virtual ~System() {}; - -private: - // singleton - System(const System &) = delete; - System(System &&) = delete; - System & operator=(const System &) = delete; - System & operator=(System &&) = delete; +public: + System() = default; + virtual ~System() = default; }; } // namespace crepe diff --git a/src/crepe/types.h b/src/crepe/types.h new file mode 100644 index 0000000..0d459e8 --- /dev/null +++ b/src/crepe/types.h @@ -0,0 +1,9 @@ +#pragma once + +#include <cstdint> + +namespace crepe { + +typedef uint32_t game_object_id_t; + +} diff --git a/src/example/CMakeLists.txt b/src/example/CMakeLists.txt index 9698c41..36f9d4d 100644 --- a/src/example/CMakeLists.txt +++ b/src/example/CMakeLists.txt @@ -22,9 +22,10 @@ add_example(script) add_example(log) add_example(rendering) add_example(asset_manager) -add_example(particle) add_example(physics) add_example(savemgr) add_example(proxy) add_example(db) +add_example(ecs) +add_example(scene_manager) diff --git a/src/example/asset_manager.cpp b/src/example/asset_manager.cpp index ba18b62..cf64f89 100644 --- a/src/example/asset_manager.cpp +++ b/src/example/asset_manager.cpp @@ -1,6 +1,6 @@ -#include <crepe/facade/Sound.h> #include <crepe/api/AssetManager.h> #include <crepe/api/Texture.h> +#include <crepe/facade/Sound.h> using namespace crepe; diff --git a/src/example/audio_internal.cpp b/src/example/audio_internal.cpp index 0b36daa..1ea839d 100644 --- a/src/example/audio_internal.cpp +++ b/src/example/audio_internal.cpp @@ -3,8 +3,8 @@ * Standalone example for usage of the internal \c Sound class. */ -#include <crepe/facade/Sound.h> #include <crepe/api/Config.h> +#include <crepe/facade/Sound.h> #include <crepe/util/log.h> #include <thread> diff --git a/src/example/ecs.cpp b/src/example/ecs.cpp new file mode 100644 index 0000000..e61c398 --- /dev/null +++ b/src/example/ecs.cpp @@ -0,0 +1,55 @@ +#include <iostream> + +#include <crepe/ComponentManager.h> +#include <crepe/api/GameObject.h> +#include <crepe/api/Metadata.h> +#include <crepe/api/Transform.h> + +using namespace crepe; +using namespace std; + +int main() { + // Create a few GameObjects + try { + GameObject body(0, "body", "person", Vector2{0, 0}, 0, 1); + GameObject right_leg(1, "rightLeg", "person", Vector2{1, 1}, 0, 1); + GameObject left_leg(2, "leftLeg", "person", Vector2{1, 1}, 0, 1); + GameObject right_foot(3, "rightFoot", "person", Vector2{2, 2}, 0, 1); + GameObject left_foot(4, "leftFoot", "person", Vector2{2, 2}, 0, 1); + + // Set the parent of each GameObject + right_foot.set_parent(right_leg); + left_foot.set_parent(left_leg); + right_leg.set_parent(body); + left_leg.set_parent(body); + + // Adding a second Transform component is not allowed and will invoke an exception + body.add_component<Transform>(Vector2{10, 10}, 0, 1); + } catch (const exception & e) { + cerr << e.what() << endl; + } + + // Get the Metadata and Transform components of each GameObject + ComponentManager & mgr = ComponentManager::get_instance(); + vector<reference_wrapper<Metadata>> metadata + = mgr.get_components_by_type<Metadata>(); + vector<reference_wrapper<Transform>> transform + = mgr.get_components_by_type<Transform>(); + + // Print the Metadata and Transform components + for (auto & m : metadata) { + cout << "Id: " << m.get().game_object_id << " Name: " << m.get().name + << " Tag: " << m.get().tag << " Parent: " << m.get().parent + << " Children: "; + for (auto & c : m.get().children) { + cout << c << " "; + } + cout << endl; + } + for (auto & t : transform) { + cout << "Id: " << t.get().game_object_id << " Position: [" + << t.get().position.x << ", " << t.get().position.y << "]" << endl; + } + + return 0; +} diff --git a/src/example/particle.cpp b/src/example/particle.cpp deleted file mode 100644 index 83b1e8a..0000000 --- a/src/example/particle.cpp +++ /dev/null @@ -1,102 +0,0 @@ -#include <chrono> -#include <iostream> -#include <thread> - -#include <crepe/Component.h> -#include <crepe/ComponentManager.h> -#include <crepe/Particle.h> -#include <crepe/facade/SDLApp.h> -#include <crepe/api/GameObject.h> -#include <crepe/api/ParticleEmitter.h> -#include <crepe/system/ParticleSystem.h> - -using namespace crepe; -using namespace std; - -const int WINDOW_WIDTH = 800; -const int WINDOW_HEIGHT = 600; - -int main(int argc, char * argv[]) { - SDLApp app(WINDOW_WIDTH, WINDOW_HEIGHT); - - if (!app.initialize()) { - cerr << "Failed to initialize SDLApp." << endl; - return 1; - } - - GameObject * game_object[1]; - game_object[0] = new GameObject(0, "Name", "Tag", 0); - - // FIXME: all systems are singletons, so this shouldn't even compile. - ParticleSystem particle_system; - - unsigned int max_particles = 100; // maximum number of particles - unsigned int emission_rate = 10; // particles created per second - unsigned int speed = 50; // base speed of particles - unsigned int speed_offset = 10; // random offset for particle speed - unsigned int angle = 270; // base angle of particle emission - unsigned int angle_offset = 30; // random offset for particle angle - float begin_lifespan = 0.0f; // beginning lifespan of particles - float end_lifespan = 6.0f; // ending lifespan of particles - - // Vector to hold all the emitters - // vector<ParticleEmitter> emitters; - game_object[0]->add_component<ParticleEmitter>( - max_particles, emission_rate, speed, speed_offset, angle, angle_offset, - begin_lifespan, end_lifespan); - - // Loop to create 1000 emitters - // for (unsigned int i = 0; i < 1000; ++i) { - // ParticleEmitter emitter(maxParticles, emissionRate, speed, speedOffset, angle, angleOffset, beginLifespan, endLifespan); - - // // Set a position for each emitter, modifying the position for demonstration - // emitter.m_position = {static_cast<float>(200 + (i % 100)), static_cast<float>(200 + (i / 100) * 10)}; // Adjust position for each emitter - - // emitters.push_back(emitter); // Add the emitter to the vector - // } - float delta_time = 0.1f; - bool running = true; - cout << "start loop " << endl; - while (running) { - app.handle_events(running); - - // Start timing - auto start = chrono::high_resolution_clock::now(); - - // POC CODE - particle_system.update(); - // POC CODE - - // End timing - auto end = chrono::high_resolution_clock::now(); - chrono::duration<float, milli> duration - = end - start; // get duration in milliseconds - - cout << "Update took " << duration.count() << " ms" << endl; - app.clear_screen(); - - start = chrono::high_resolution_clock::now(); - // render particles using the draw_square method from SDLApp - ComponentManager & mgr = ComponentManager::get_instance(); - std::vector<std::reference_wrapper<ParticleEmitter>> emitters - = mgr.get_components_by_type<ParticleEmitter>(); - for (const ParticleEmitter & emitter : emitters) { - for (const Particle & particle : emitter.particles) { - if (particle.active) - app.draw_square(particle.position.x, particle.position.y, - 5); // draw each particle - } - } - - app.present_screen(); - end = chrono::high_resolution_clock::now(); - duration = end - start; // get duration in milliseconds - - cout << "screen took " << duration.count() << " ms" << endl; - - this_thread::sleep_for(chrono::milliseconds(20)); // simulate ~50 FPS - } - - app.clean_up(); - return 0; -} diff --git a/src/example/physics.cpp b/src/example/physics.cpp index 2dbddc2..848f857 100644 --- a/src/example/physics.cpp +++ b/src/example/physics.cpp @@ -1,10 +1,5 @@ -#include <chrono> -#include <iostream> -#include <thread> - #include <crepe/Component.h> #include <crepe/ComponentManager.h> -#include <crepe/api/Force.h> #include <crepe/api/GameObject.h> #include <crepe/api/Rigidbody.h> #include <crepe/api/Transform.h> @@ -14,17 +9,16 @@ using namespace crepe; using namespace std; int main(int argc, char * argv[]) { - PhysicsSystem physics_system; - GameObject * game_object[2]; - game_object[1] = new GameObject(2, "Name", "Tag", 0); // not found not used - game_object[0] = new GameObject(5, "Name", "Tag", 0); - Point point = { - .x = 0, - .y = 0, - }; - game_object[0]->add_component<Transform>(point, 0, 0); - game_object[0]->add_component<Rigidbody>(1, 1, BodyType::DYNAMIC); - game_object[0]->add_component<Force>(1, 0); - physics_system.update(); + GameObject * game_object; + game_object = new GameObject(0, "Name", "Tag", Vector2{0, 0}, 0, 0); + game_object->add_component<Rigidbody>(Rigidbody::Data{ + .mass = 1, + .gravity_scale = 1, + .body_type = Rigidbody::BodyType::DYNAMIC, + .constraints = {0, 0, 0}, + .use_gravity = true, + .bounce = false, + }); + delete game_object; return 0; } diff --git a/src/example/rendering.cpp b/src/example/rendering.cpp index b0ab60a..d554a8a 100644 --- a/src/example/rendering.cpp +++ b/src/example/rendering.cpp @@ -5,10 +5,10 @@ #include <crepe/api/AssetManager.h> #include <crepe/api/Color.h> -#include <crepe/api/Point.h> #include <crepe/api/Sprite.h> #include <crepe/api/Texture.h> #include <crepe/api/Transform.h> +#include <crepe/api/Vector2.h> #include <chrono> #include <memory> @@ -17,22 +17,16 @@ using namespace std; using namespace crepe; int main() { - dbg_trace(); - auto obj = GameObject(0, "name", "tag", 0); - auto obj1 = GameObject(1, "name", "tag", 0); - auto obj2 = GameObject(2, "name", "tag", 0); + auto obj = GameObject(0, "name", "tag", Vector2{0, 0}, 1, 1); + auto obj1 = GameObject(1, "name", "tag", Vector2{500, 0}, 1, 0.1); + auto obj2 = GameObject(2, "name", "tag", Vector2{800, 0}, 1, 0.1); auto & mgr = AssetManager::get_instance(); // Normal adding components { Color color(0, 0, 0, 0); - Point point = { - .x = 0, - .y = 0, - }; - obj.add_component<Transform>(point, 1, 1); obj.add_component<Sprite>( make_shared<Texture>("../asset/texture/img.png"), color, FlipSettings{true, true}); @@ -40,22 +34,12 @@ int main() { { Color color(0, 0, 0, 0); - Point point = { - .x = 500, - .y = 0, - }; - obj1.add_component<Transform>(point, 0, 0.1); auto img = mgr.cache<Texture>("../asset/texture/second.png"); obj1.add_component<Sprite>(img, color, FlipSettings{true, true}); } { Color color(0, 0, 0, 0); - Point point = { - .x = 800, - .y = 0, - }; - //obj.add_component<Transform>(point, 0, 0.1); auto img = mgr.cache<Texture>("../asset/texture/second.png"); obj2.add_component<Sprite>(img, color, FlipSettings{true, true}); } diff --git a/src/example/scene_manager.cpp b/src/example/scene_manager.cpp new file mode 100644 index 0000000..f46dc36 --- /dev/null +++ b/src/example/scene_manager.cpp @@ -0,0 +1,75 @@ +#include <iostream> + +#include <crepe/ComponentManager.h> +#include <crepe/api/GameObject.h> +#include <crepe/api/Metadata.h> +#include <crepe/api/Scene.h> +#include <crepe/api/SceneManager.h> +#include <crepe/api/Vector2.h> + +using namespace crepe; +using namespace std; + +class ConcreteScene1 : public Scene { +public: + ConcreteScene1(string name) : Scene(name) {} + + void load_scene() { + GameObject object1(0, "scene_1", "tag_scene_1", Vector2{0, 0}, 0, 1); + GameObject object2(1, "scene_1", "tag_scene_1", Vector2{1, 0}, 0, 1); + GameObject object3(2, "scene_1", "tag_scene_1", Vector2{2, 0}, 0, 1); + } +}; + +class ConcreteScene2 : public Scene { +public: + ConcreteScene2(string name) : Scene(name) {} + + void load_scene() { + GameObject object1(0, "scene_2", "tag_scene_2", Vector2{0, 0}, 0, 1); + GameObject object2(1, "scene_2", "tag_scene_2", Vector2{0, 1}, 0, 1); + GameObject object3(2, "scene_2", "tag_scene_2", Vector2{0, 2}, 0, 1); + GameObject object4(3, "scene_2", "tag_scene_2", Vector2{0, 3}, 0, 1); + } +}; + +int main() { + SceneManager & scene_mgr = SceneManager::get_instance(); + + // Add the scenes to the scene manager + scene_mgr.add_scene<ConcreteScene1>("scene1"); + scene_mgr.add_scene<ConcreteScene2>("scene2"); + + // There is no need to call set_next_scene() at the beginnen, because the first scene will be automatically set as the next scene + // Load scene1 (the first scene added) + scene_mgr.load_next_scene(); + + // Get the Metadata components of each GameObject of Scene1 + ComponentManager & component_mgr = ComponentManager::get_instance(); + vector<reference_wrapper<Metadata>> metadata + = component_mgr.get_components_by_type<Metadata>(); + + cout << "Metadata components of Scene1:" << endl; + // Print the Metadata + for (auto & m : metadata) { + cout << "Id: " << m.get().game_object_id << " Name: " << m.get().name + << " Tag: " << m.get().tag << endl; + } + + // Set scene2 as the next scene + scene_mgr.set_next_scene("scene2"); + // Load scene2 + scene_mgr.load_next_scene(); + + // Get the Metadata components of each GameObject of Scene2 + metadata = component_mgr.get_components_by_type<Metadata>(); + + cout << "Metadata components of Scene2:" << endl; + // Print the Metadata + for (auto & m : metadata) { + cout << "Id: " << m.get().game_object_id << " Name: " << m.get().name + << " Tag: " << m.get().tag << endl; + } + + return 0; +} diff --git a/src/example/script.cpp b/src/example/script.cpp index dac7af3..9e8b147 100644 --- a/src/example/script.cpp +++ b/src/example/script.cpp @@ -36,18 +36,12 @@ class MyScript : public Script { int main() { // Create game object with Transform and BehaviorScript components - auto obj = GameObject(0, "name", "tag", 0); - obj.add_component<Transform>( - Point{ - .x = 1.2, - .y = 3.4, - }, - 0, 0); + auto obj = GameObject(0, "name", "tag", Vector2{1.2, 3.4}, 0, 1); obj.add_component<BehaviorScript>().set_script<MyScript>(); // Get ScriptSystem singleton instance (this would normally be done from the // game loop) - auto & sys = ScriptSystem::get_instance(); + ScriptSystem sys; // Update all scripts. This should result in MyScript::update being called sys.update(); diff --git a/src/makefile b/src/makefile index 3f74a2a..b9c44c8 100644 --- a/src/makefile +++ b/src/makefile @@ -1,8 +1,104 @@ .PHONY: FORCE -FMT += $(shell git ls-files '*.c' '*.cpp' '*.h' '*.hpp') +# STEPS FOR BIG CLEANUP +# +# 1. Change TODO to your name (in capitals) for each file in the list below +# that is yours (or you are going to fix) +# 2. Update the name between parentheses below this list (see comment) to your +# name +# 3. Create a git commit at this point (ensure `git status` reports "working +# tree clean") +# 4. Run `make format` in the REPOSITORY ROOT DIRECTORY (NOT HERE), and start +# fixing reported errors or miscorrections manually until everything works +# again. +# 5. Once everything is working again, create another git commit, and create a +# pull request. Make sure to ask someone to review the code standards for +# each ENTIRE FILE in this pull request. + +LOEK += crepe/Asset.cpp +LOEK += crepe/Asset.h +TODO += crepe/Collider.cpp +TODO += crepe/Collider.h +MAX += crepe/Component.cpp +MAX += crepe/Component.h +MAX += crepe/ComponentManager.cpp +MAX += crepe/ComponentManager.h +MAX += crepe/ComponentManager.hpp +MAX += crepe/api/Metadata.cpp +MAX += crepe/api/Metadata.h +TODO += crepe/Particle.cpp +TODO += crepe/Particle.h +TODO += crepe/Position.h +TODO += crepe/api/AssetManager.cpp +TODO += crepe/api/AssetManager.h +TODO += crepe/api/AssetManager.hpp +LOEK += crepe/api/AudioSource.cpp +LOEK += crepe/api/AudioSource.h +LOEK += crepe/api/BehaviorScript.cpp +LOEK += crepe/api/BehaviorScript.h +LOEK += crepe/api/BehaviorScript.hpp +TODO += crepe/api/CircleCollider.h +TODO += crepe/api/Color.cpp +TODO += crepe/api/Color.h +LOEK += crepe/api/Config.h +MAX += crepe/api/GameObject.cpp +MAX += crepe/api/GameObject.h +MAX += crepe/api/GameObject.hpp +TODO += crepe/api/ParticleEmitter.cpp +TODO += crepe/api/ParticleEmitter.h +TODO += crepe/api/Vector2.h +TODO += crepe/api/Vector2.cpp +JARO += crepe/api/Rigidbody.cpp +JARO += crepe/api/Rigidbody.h +LOEK += crepe/api/Script.cpp +LOEK += crepe/api/Script.h +LOEK += crepe/api/Script.hpp +TODO += crepe/api/Sprite.cpp +TODO += crepe/api/Sprite.h +TODO += crepe/api/Texture.cpp +TODO += crepe/api/Texture.h +MAX += crepe/api/Transform.cpp +MAX += crepe/api/Transform.h +TODO += crepe/facade/SDLContext.cpp +TODO += crepe/facade/SDLContext.h +LOEK += crepe/facade/Sound.cpp +LOEK += crepe/facade/Sound.h +LOEK += crepe/facade/SoundContext.cpp +LOEK += crepe/facade/SoundContext.h +TODO += crepe/system/CollisionSystem.cpp +TODO += crepe/system/CollisionSystem.h +TODO += crepe/system/ParticleSystem.cpp +TODO += crepe/system/ParticleSystem.h +JARO += crepe/system/PhysicsSystem.cpp +JARO += crepe/system/PhysicsSystem.h +TODO += crepe/system/RenderSystem.cpp +TODO += crepe/system/RenderSystem.h +LOEK += crepe/system/ScriptSystem.cpp +LOEK += crepe/system/ScriptSystem.h +LOEK += crepe/system/System.h +LOEK += crepe/util/LogColor.cpp +LOEK += crepe/util/LogColor.h +LOEK += crepe/util/fmt.cpp +LOEK += crepe/util/fmt.h +LOEK += crepe/util/log.cpp +LOEK += crepe/util/log.h +TODO += example/asset_manager.cpp +LOEK += example/audio_internal.cpp +TODO += example/components_internal.cpp +MAX += example/ecs.cpp +LOEK += example/log.cpp +TODO += example/particle.cpp +JARO += example/physics.cpp +TODO += example/rendering.cpp +LOEK += example/script.cpp +LOEK += test/audio.cpp +LOEK += test/dummy.cpp +JARO += test/PhysicsTest.cpp + +FMT := $(JARO) #<<< CHANGE THIS TO YOUR NAME FOR STEP 2 format: FORCE - # clang-tidy -p build/compile_commands.json --fix-errors $(FMT) + clang-tidy -p build/compile_commands.json --fix-errors $(FMT) -# TODO: re-enable linter after 2024-11-10 +# FMT += $(shell git ls-files '*.c' '*.cpp' '*.h' '*.hpp') +# TODO: re-enable linter after all corrections diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt index 0d316d6..0e4eaed 100644 --- a/src/test/CMakeLists.txt +++ b/src/test/CMakeLists.txt @@ -1,5 +1,6 @@ target_sources(test_main PUBLIC dummy.cpp # audio.cpp + PhysicsTest.cpp ) diff --git a/src/test/PhysicsTest.cpp b/src/test/PhysicsTest.cpp new file mode 100644 index 0000000..5385962 --- /dev/null +++ b/src/test/PhysicsTest.cpp @@ -0,0 +1,120 @@ +#include <crepe/ComponentManager.h> +#include <crepe/api/Config.h> +#include <crepe/api/GameObject.h> +#include <crepe/api/Rigidbody.h> +#include <crepe/api/Transform.h> +#include <crepe/system/PhysicsSystem.h> +#include <gtest/gtest.h> + +using namespace std; +using namespace std::chrono_literals; +using namespace crepe; + +class PhysicsTest : public ::testing::Test { +protected: + GameObject * game_object; + PhysicsSystem physics_system; + void SetUp() override { + ComponentManager & mgr = ComponentManager::get_instance(); + std::vector<std::reference_wrapper<Transform>> transforms + = mgr.get_components_by_id<Transform>(0); + if (transforms.empty()) { + game_object = new GameObject(0, "", "", Vector2{0, 0}, 0, 0); + game_object->add_component<Rigidbody>(Rigidbody::Data{ + .mass = 1, + .gravity_scale = 1, + .body_type = Rigidbody::BodyType::DYNAMIC, + .max_linear_velocity = Vector2{10, 10}, + .max_angular_velocity = 10, + .constraints = {0, 0}, + .use_gravity = true, + .bounce = false, + }); + } + transforms = mgr.get_components_by_id<Transform>(0); + Transform & transform = transforms.front().get(); + transform.position.x = 0.0; + transform.position.y = 0.0; + transform.rotation = 0.0; + std::vector<std::reference_wrapper<Rigidbody>> rigidbodies + = mgr.get_components_by_id<Rigidbody>(0); + Rigidbody & rigidbody = rigidbodies.front().get(); + rigidbody.data.angular_velocity = 0; + rigidbody.data.linear_velocity.x = 0; + rigidbody.data.linear_velocity.y = 0; + } +}; + +TEST_F(PhysicsTest, gravity) { + Config::get_instance().physics.gravity = 1; + ComponentManager & mgr = ComponentManager::get_instance(); + std::vector<std::reference_wrapper<Transform>> transforms + = mgr.get_components_by_id<Transform>(0); + const Transform & transform = transforms.front().get(); + ASSERT_FALSE(transforms.empty()); + EXPECT_EQ(transform.position.y, 0); + physics_system.update(); + EXPECT_EQ(transform.position.y, 1); + physics_system.update(); + EXPECT_EQ(transform.position.y, 3); +} + +TEST_F(PhysicsTest, max_velocity) { + ComponentManager & mgr = ComponentManager::get_instance(); + std::vector<std::reference_wrapper<Rigidbody>> rigidbodies + = mgr.get_components_by_id<Rigidbody>(0); + Rigidbody & rigidbody = rigidbodies.front().get(); + ASSERT_FALSE(rigidbodies.empty()); + EXPECT_EQ(rigidbody.data.linear_velocity.y, 0); + rigidbody.add_force_linear({100, 100}); + rigidbody.add_force_angular(100); + physics_system.update(); + EXPECT_EQ(rigidbody.data.linear_velocity.y, 10); + EXPECT_EQ(rigidbody.data.linear_velocity.x, 10); + EXPECT_EQ(rigidbody.data.angular_velocity, 10); + rigidbody.add_force_linear({-100, -100}); + rigidbody.add_force_angular(-100); + physics_system.update(); + EXPECT_EQ(rigidbody.data.linear_velocity.y, -10); + EXPECT_EQ(rigidbody.data.linear_velocity.x, -10); + EXPECT_EQ(rigidbody.data.angular_velocity, -10); +} + +TEST_F(PhysicsTest, movement) { + Config::get_instance().physics.gravity = 0; + ComponentManager & mgr = ComponentManager::get_instance(); + std::vector<std::reference_wrapper<Rigidbody>> rigidbodies + = mgr.get_components_by_id<Rigidbody>(0); + Rigidbody & rigidbody = rigidbodies.front().get(); + std::vector<std::reference_wrapper<Transform>> transforms + = mgr.get_components_by_id<Transform>(0); + const Transform & transform = transforms.front().get(); + ASSERT_FALSE(rigidbodies.empty()); + ASSERT_FALSE(transforms.empty()); + rigidbody.add_force_linear({1, 1}); + rigidbody.add_force_angular(1); + physics_system.update(); + EXPECT_EQ(transform.position.x, 1); + EXPECT_EQ(transform.position.y, 1); + EXPECT_EQ(transform.rotation, 1); + rigidbody.data.constraints = {1, 1, 1}; + EXPECT_EQ(transform.position.x, 1); + EXPECT_EQ(transform.position.y, 1); + EXPECT_EQ(transform.rotation, 1); + rigidbody.data.linear_damping.x = 0.5; + rigidbody.data.linear_damping.y = 0.5; + rigidbody.data.angular_damping = 0.5; + physics_system.update(); + EXPECT_EQ(rigidbody.data.linear_velocity.x, 0.5); + EXPECT_EQ(rigidbody.data.linear_velocity.y, 0.5); + EXPECT_EQ(rigidbody.data.angular_velocity, 0.5); + rigidbody.data.constraints = {1, 1, 0}; + rigidbody.data.angular_damping = 0; + rigidbody.data.max_angular_velocity = 1000; + rigidbody.data.angular_velocity = 360; + physics_system.update(); + EXPECT_EQ(transform.rotation, 1); + rigidbody.data.angular_velocity = -360; + physics_system.update(); + EXPECT_EQ(transform.rotation, 1); +} |