Usefull Scripts & Components

I updated today the controller to a new version. I adjusted some parameters that the camera looks more like an isometric view. 

MouseMovementController.h

#pragma once
#include "UltraEngine.h"
#include "../BaseComponent.h"

using namespace UltraEngine;

class MouseMovementController : public BaseComponent
{
public: 
    std::weak_ptr<NavMesh> navmesh;
    std::shared_ptr<Camera> camera;
    std::shared_ptr<NavAgent> navagent;

    string runanimation;
    string idleanimation;
    Vec3 destination;

    MouseMovementController();

    virtual void Start();
    virtual void Update();
    virtual void Collide(std::shared_ptr<Entity> collidedentity, const Vec3& position, const Vec3& normal, const float speed);
    virtual bool ProcessEvent(const Event& e);
	virtual bool Load(table& properties, std::shared_ptr<Stream> binstream, std::shared_ptr<Scene> scene, const LoadFlags flags, std::shared_ptr<Object> extra);
    virtual bool Save(table& properties, std::shared_ptr<Stream> binstream, std::shared_ptr<Scene> scene, const SaveFlags flags, std::shared_ptr<Object> extra);
    virtual std::shared_ptr<Component> Copy();
    virtual std::any CallMethod(shared_ptr<Component> sender, const WString& name, const std::vector<std::any>& arguments);
};

MouseMovementController.cpp

#pragma once
#include "UltraEngine.h"
#include "MouseMovementController.h"

using namespace UltraEngine;

bool PickFilter(std::shared_ptr<Entity> entity, std::shared_ptr<Object> extra)
{
    if (entity->As<Terrain>()) {
        return true;
    }
    return false;
}

MouseMovementController::MouseMovementController()
{ 
    name = "MouseMovementController";
}

void MouseMovementController::Start()
{
    //Listen(EVENT_KEYDOWN, NULL);// makes this component listen for keydown events from all windows
    auto entity = GetEntity();
    ///Create the camera and attach them to the player character
    this->camera = CreateCamera(entity->GetWorld());
    Vec3 currentcameraposition = TransformPoint(0, 15, 5, entity, nullptr);
    //this->camera->SetParent(entity);
    this->camera->SetPosition(currentcameraposition, true);
    this->camera->SetRotation(Vec3(45, 0, 0));
    this->camera->SetFov(40);
    this->camera->Point(entity);

    auto navmesh = this->navmesh.lock();
    this->navagent = CreateNavAgent(navmesh);
    this->navagent->SetPosition(entity->GetPosition(true));
    this->navagent->SetMaxSpeed(5.0f);
    entity->SetPosition(0, 0, 0);
    entity->SetRotation(0, 0, 0);
    entity->Attach(this->navagent);
}

void MouseMovementController::Update()
{
    auto entity = GetEntity();
    auto window = ActiveWindow();
    auto world = entity->GetWorld();

    if (window) {
        ///Set the destination if the player hits the left mouse button
        if (window->MouseDown(MOUSE_LEFT)) {
            auto mousePosition = window->GetMousePosition();
            auto pick = this->camera->Pick(window->GetFramebuffer(), mousePosition.x, mousePosition.y, 0, false, PickFilter);
            if (pick.success)
            {
                this->destination = pick.position;
            }
        }

        ///Move to the destination if the destination is not null
        if (this->destination != NULL) {
            if (entity->position.DistanceToPoint(this->destination) > 1.0f)
            {
                this->navagent->Navigate(this->destination);
                auto model = entity->As<Model>();
                model->Animate(this->runanimation);
            }
            else {
                this->navagent->Stop();
                auto model = entity->As<Model>();
                model->Animate(idleanimation);
                this->destination == NULL;
            }
        }


        Vec3 offset = Vec3(-10, 15, -10);
        Vec3 currentcameraposition = entity->position + offset;
        this->camera->SetPosition(currentcameraposition, true);
        this->camera->Point(entity);
    }
}

void MouseMovementController::Collide(shared_ptr<Entity> collidedentity, const Vec3& position, const Vec3& normal, const float speed)
{
    
}

bool MouseMovementController::ProcessEvent(const Event& e)
{
    /*switch (e.id)
    {
    case EVENT_KEYDOWN:
        if (e.data == KEY_SPACE)
        {
            Print("Space key pressed");
        }
        break;
    }*/
    return true;
}

bool MouseMovementController::Load(table& properties, shared_ptr<Stream> binstream, shared_ptr<Scene> scene, const LoadFlags flags, std::shared_ptr<Object> extra)
{
    this->runanimation = (String)properties["runanimation"];
    this->idleanimation = (String)properties["idleanimation"];

    auto navmesh_entity = scene->GetEntity((String)properties["navmesh"]);
    this->navmesh = scene->navmeshes[(int)navmesh_entity->properties["navmesh"]];

    //return true;
    return BaseComponent::Load(properties, binstream, scene, flags, extra);
}

bool MouseMovementController::Save(table& properties, shared_ptr<Stream> binstream, shared_ptr<Scene> scene, const SaveFlags flags, std::shared_ptr<Object> extra)
{
    return BaseComponent::Save(properties, binstream, scene, flags, extra);
}

//This method will work with simple components
shared_ptr<Component> MouseMovementController::Copy()
{
    return std::make_shared<MouseMovementController>(*this);
}

std::any MouseMovementController::CallMethod(shared_ptr<Component> sender, const WString& name, const std::vector<std::any>& arguments)
{
    /*if (name == "MyMethod")
    {
        MyMethod();
        return false;
    }*/
    return BaseComponent::CallMethod(sender, name, arguments);
}

MouseMovementController.json

{
    "component":
    {
        "properties":
        [
            {
                "name": "runanimation",
                "label": "Run Animation",
                "value": ""
            },
            {
                "name": "idleanimation",
                "label": "Idle Animation",
                "value": ""
            },
            {
                "name": "navmesh",
                "label": "Navmesh",
                "value": null
            }
        ]
    }
}

Here you can find how it looks now: Watch 2024-12-12 17-12-32 | Streamable