PlayerMouvementSystem.cpp

Go to the documentation of this file.

 
#include "Systems/PlayerMouvementSystem.hpp"
 
namespace rtp::server
{
    // Public API
 
    PlayerMouvementSystem::PlayerMouvementSystem(ecs::Registry &registry)
        : _registry(registry)
    {
    }
 
    void PlayerMouvementSystem::update(float dt)
    {
        (void)dt;
        auto view =
            _registry.zipView<ecs::components::Transform,
                              ecs::components::Velocity,
                              ecs::components::server::InputComponent,
                              ecs::components::EntityType,
                              ecs::components::MovementSpeed>();
 
        for (auto &&[tf, vel, input, type, speed] : view) {
            if (type.type != net::EntityType::Player)
                continue;
 
            if (speed.boostRemaining > 0.0f) {
                speed.boostRemaining -= dt;
                if (speed.boostRemaining <= 0.0f) {
                    speed.boostRemaining = 0.0f;
                    speed.multiplier = 1.0f;
                }
            }
 
            const float finalSpeed = speed.baseSpeed * speed.multiplier;
 
            float dx = 0.f, dy = 0.f;
            using Bits =
                ecs::components::server::InputComponent::InputBits;
 
            if (input.mask & Bits::MoveUp)
                dy -= 1.f;
            if (input.mask & Bits::MoveDown)
                dy += 1.f;
            if (input.mask & Bits::MoveLeft)
                dx -= 1.f;
            if (input.mask & Bits::MoveRight)
                dx += 1.f;
 
            const float len = std::sqrt(dx * dx + dy * dy);
            if (len > 0.f) {
                dx /= len;
                dy /= len;
            }
 
            const float targetX = dx * finalSpeed;
            const float targetY = dy * finalSpeed;
 
            constexpr float accel = 8.0f;
            constexpr float decel = 10.0f;
 
            if (dx != 0.f || dy != 0.f) {
                vel.direction.x += (targetX - vel.direction.x) * accel * dt;
                vel.direction.y += (targetY - vel.direction.y) * accel * dt;
            } else {
                vel.direction.x += (0.0f - vel.direction.x) * decel * dt;
                vel.direction.y += (0.0f - vel.direction.y) * decel * dt;
            }
        }
    }
} // namespace rtp::server