> For the complete documentation index, see [llms.txt](https://kap35.gitbook.io/kap-engine-wiki/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://kap35.gitbook.io/kap-engine-wiki/user-manual/component/create-new-one.md).

# Create new one

### Prototype

.hpp

```cpp
#include "KapEngine.hpp"

namespace KapEngine {
    namespace MyGame {
        
        class MyComponent : public Component {
            public:
                //constructuer du composant sans préciser son thread
                MyComponent(std::shared_ptr<GameObject> go);
                ~MyComponent();

                /**
                 * Fonctionnalité de base d'un composant
                */

                //appelé lors de l'initialisation du composant (au runtime) deprecated
                void onInit() override;
                //appelé lors du premier chargement de la scène OU quand on charge la scène après qu'une autre scène ai été chargé
                void onAwake() override;
                //appelé à chaque chargement / rechargement de la scène
                void onStart() override;
                //appelé à chaque frame
                void onUpdate() override;
                //appelé à chaque X ms. (X étant le nombre définie par vous dans l'engine. De base X = 25)
                void onFixedUpdate() override;
                //appelé après toutes les fonctions de mise à jour
                void onDisplay() override;

                /**
                 * Fonctionnalité lorsque votre GameObject (objet de jeu) à un composant collider sur lui
                 * 
                 * Attnetion !
                 * Les fonctions suivantes, ne seront pas appelé lors des fonctions mise à jour (au dessus)
                 * ces fonctions peuvent être appelé plus tard ou avant
                */

                //appelé lors du passage de la souris sur l'objet
                void onMouseEnter() override;
                //appelé lorsque la souris reste sur l'objet
                void onMouseStay() override;
                //appelé lors de la sortie de la souris sur l'objet
                void onMouseExit() override;

                //appelé lorsqu'un objet rentre dans l'objet rattaché
                void onTriggerEnter(std::shared_ptr<GameObject> go) override;
                //appelé lorsqu'un objet reste dans l'objet rattaché
                void onTriggerStay(std::shared_ptr<GameObject> go) override;
                //appelé lorsqu'un objet sort dans l'objet rattaché
                void onTriggerExit(std::shared_ptr<GameObject> go) override;
                //ajoutez des conditions au lancement de votre composant
                bool checkComponentValidity() override;
                //appelé lorsque votre objet est détruit
                void onDestroy() override;
                //appelé lorsque le jeu se quitte
                void onGameQuit() override;
                //appelé lorsque le GameObject se désactive
                void onDisable() override;
                //appelé lorsque le GameObject s'active
                void onEnable() override;

        }
        
    }
}
```

.cpp

```cpp
#include "MyComponent.hpp"

KapEngine::MyGame::MyComponent(std::shared_ptr<GameObject> go) : Component(go, "MyComponent") {
    Debug::log("Creating component...");
}

KapEngine::MyGame::~MyComponent() {
    Debug::log("Deleting component...");
}

void KapEngine::MyGame::MyComponent::onAwake() {
    Debug::log("My component awake !");
}

void KapEngine::MyGame::MyComponent::onStart() {
    Debug::log("Starting component !");
}

void KapEngine::MyGame::MyComponent::onUpdate() {
    Debug::log("Update component !");
}

void KapEngine::MyGame::MyComponent::onFixedUpdate() {
    Debug::log("Fixed Update component !");
}

void KapEngine::MyGame::MyComponent::onDisplay() {
    Debug::log("Display component !");
}

void MonComposant::onMouseEnter() {
    Debug::log("Mouse entered in object");
}

void MonComposant::onMouseStay() {
    Debug::log("Mouse stay in object");
}

void KapEngine::MyGame::MyComponent::onMouseExit() {
    Debug::log("Mouse exit object");
}

void KapEngine::MyGame::MyComponent::onTriggerEnter(std::shared_ptr<GameObject> go) {
    Debug::log("The object: " + go->getName() + " entered in my object");
}

void KapEngine::MyGame::MyComponent::onTriggerStay(std::shared_ptr<GameObject> go) {
    Debug::log("The object: " + go->getName() + " stays in my object");
}

void KapEngine::MyGame::MyComponent::onTriggerExit(std::shared_ptr<GameObject> go) {
    Debug::log("The object: " + go->getName() + " comes out of my object");
}

bool KapEngine::MyGame::MyComponent::checkComponentValidity() {
    if (...) {
        //my component should not start
        return false;
    }
    //my component can start
    return true;
}

void KapEngine::MyGame::MyComponent::onDestroy() {
    Debug::log("The object " + getGameObject().getName() + " is destroy");
}

void KapEngine::MyGame::MyComponent::onGameQuit() {
    Debug::log("Game is stopping");
}

void KapEngine::MyGame::MyComponent::onDisable() {
    Debug::log("The object " + getGameObject().getName() + " is now disable");
}

void KapEngine::MyGame::MyComponent::onEnable() {
    Debug::log("The object " + getGameObject().getName() + " is now enable");
}


```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://kap35.gitbook.io/kap-engine-wiki/user-manual/component/create-new-one.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.