holesome/src/game/input/direction.cpp

#include <map>
#include "direction.h"
#include "../../utilities/vector_utils.hpp"
#include "../../config.h"

HardDirection Direction::getKeyDirection(sf::Keyboard::Key key)
{
    auto map = std::map<sf::Keyboard::Key, HardDirection>();
    map[sf::Keyboard::W] = HardDirection::UP;
    map[sf::Keyboard::S] = HardDirection::DOWN;
    map[sf::Keyboard::A] = HardDirection::LEFT;
    map[sf::Keyboard::D] = HardDirection::RIGHT;
    map[sf::Keyboard::Up] = HardDirection::UP;
    map[sf::Keyboard::Down] = HardDirection::DOWN;
    map[sf::Keyboard::Left] = HardDirection::LEFT;
    map[sf::Keyboard::Right] = HardDirection::RIGHT;

    if (map.find(key) == map.end())
        return HardDirection::NONE;

    return map[key];
}

sf::Vector2f Direction::getScreenVector(HardDirection direction)
{
    auto vector = getVector(direction);
    vector.y *= -1;
    return vector;
}

sf::Vector2f Direction::getVector(HardDirection direction)
{
    auto vector = sf::Vector2f(0.0f, 0.0f);

    if (direction == HardDirection::NONE)
    {
        return vector;
    }

    // Combine all relevant directions into one vector
    if (direction & HardDirection::UP)
    {
        vector.y += 1;
    }
    if (direction & HardDirection::DOWN)
    {
        vector.y -= 1;
    }
    if (direction & HardDirection::LEFT)
    {
        vector.x -= 1;
    }
    if (direction & HardDirection::RIGHT)
    {
        vector.x += 1;
    }

    return normalize(vector);
}

HardDirection Direction::getHardDirectionFromVector(sf::Vector2f vector)
{
    HardDirection direction = HardDirection::NONE;
    vector = normalize(vector);
    auto absVector = abs(vector);

    // X axis
    if (absVector.x >= DIRECTION_HARD_ACTIVATION_THRESHOLD)
    {
        if (vector.x > 0)
        {
            direction = static_cast<HardDirection>(direction | HardDirection::RIGHT);
        } else
        {
            direction = static_cast<HardDirection>(direction | HardDirection::LEFT);
        }
    }

    // Y axis
    if (absVector.y >= DIRECTION_HARD_ACTIVATION_THRESHOLD)
    {
        if (vector.y > 0)
        {
            direction = static_cast<HardDirection>(direction | HardDirection::DOWN);
        } else
        {
            direction = static_cast<HardDirection>(direction | HardDirection::UP);
        }
    }

    return direction;
}

sf::Vector2f Direction::asVector() const
{
    return directionVector;
}

HardDirection Direction::asHardDirection() const
{
    return getHardDirectionFromVector(directionVector);
}

Direction::Direction(sf::Vector2f directionVector)
{
    this->directionVector = directionVector;
}

Direction::Direction(HardDirection direction)
{
    this->directionVector = getVector(direction);
}

sf::Vector2f Direction::asScreenVector() const
{
    auto screenVector = directionVector;
    screenVector.y *= -1;
    return screenVector;
}

Direction::Direction()
{
    directionVector = sf::Vector2f(0.0f, 0.0f);
}

void Direction::add(HardDirection direction)
{
    summedDirections = static_cast<HardDirection>(summedDirections | direction);
    directionVector = getVector(summedDirections);
}

void Direction::remove(HardDirection direction)
{
    summedDirections = static_cast<HardDirection>(summedDirections & ~direction);
    directionVector = getVector(summedDirections);
}

void Direction::set(HardDirection direction)
{
    summedDirections = direction;
    directionVector = getVector(summedDirections);
}

void Direction::clear()
{
    summedDirections = HardDirection::NONE;
    directionVector = sf::Vector2f(0.0f, 0.0f);
}

void Direction::set(sf::Vector2f direction)
{
    summedDirections = HardDirection::NONE;
    this->directionVector = direction;
}

void Direction::setX(float value)
{
    sf::Vector2f newDirection = {value, directionVector.y};
    set(newDirection);
}

void Direction::setY(float value)
{
    sf::Vector2f newDirection = {directionVector.x, value};
    set(newDirection);
}