Users.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTAS_INTEGRATIONS_USER_ACTION_USERS_HPP_
#define ECSTAS_INTEGRATIONS_USER_ACTION_USERS_HPP_
 
#include <vector>
#include "UserProfile.hpp"
#include "ecstasy/integrations/event/events/Event.hpp"
#include "ecstasy/integrations/event/inputs/Gamepad.hpp"
#include "ecstasy/integrations/event/inputs/Keyboard.hpp"
#include "ecstasy/integrations/event/inputs/Mouse.hpp"
#include "ecstasy/registry/Registry.hpp"
#include "ecstasy/resources/IResource.hpp"
#include "ecstasy/storages/MapStorage.hpp"
#include <unordered_map>
 
namespace
{
    namespace event = ecstasy::integration::event;
}
 
namespace ecstasy::integration::user_action
{
    class Users : public ecstasy::IResource {
      private:
        struct UserActionLink {
            Action::Id actionId;
            UserProfile::Id userId;
        };
 
      public:
        Users(size_t count = 1);
 
        ~Users() = default;
 
        void updateBindings();
 
        static void updateBindings(Registry &registry);
 
        void handleEvent(Registry &registry, const event::Event &event) const;
 
        [[nodiscard]] constexpr UserProfile &getUserProfile(size_t index = 0)
        {
            return _users[index];
        }
 
        [[nodiscard]] constexpr const UserProfile &getUserProfile(size_t index = 0) const
        {
            return _users[index];
        }
 
      private:
        template <typename T>
        void removeOutdatedBindings(std::unordered_multimap<T, UserActionLink> &map)
        {
            for (auto it = map.begin(); it != map.end();) {
                if (it->second.userId >= _users.size()
                    || !_users[it->second.userId].getActionBindings().contains(
                        ActionBinding(it->second.actionId, it->first)))
                    it = map.erase(it);
                else
                    ++it;
            }
        }
 
        template <typename T>
        void addBindingIfMissing(const UserProfile &user, const ActionBinding &binding, T input,
            std::unordered_multimap<T, UserActionLink> &map)
        {
            bool add = true;
            auto range = map.equal_range(input);
 
            for (auto it = range.first; it != range.second; ++it) {
                if (it->second.userId == user.getId() && it->second.actionId == binding.actionId) {
                    add = false;
                    break;
                }
            }
            if (add)
                map.insert({input, UserActionLink{binding.actionId, user.getId()}});
        }
 
        static void callActionListeners(Registry &registry, Action action);
 
        template <typename T>
        static void callListenersFromMap(
            Registry &registry, const std::unordered_multimap<T, Users::UserActionLink> &map, T key, float value)
        {
            auto range = map.equal_range(key);
            for (auto it = range.first; it != range.second; ++it)
                callActionListeners(registry, Action{it->second.actionId, it->second.userId, value});
        }
 
        // Link between the mouse buttons and the associated actions.
        std::unordered_multimap<event::Mouse::Button, UserActionLink> _mouseButtonToAction;
        // Link between the keyboard keys and the associated actions.
        std::unordered_multimap<event::Keyboard::Key, UserActionLink> _keyToAction;
        // Link between the gamepad buttons and the associated actions.
        std::unordered_multimap<event::Gamepad::Button, UserActionLink> _gamepadButtonToAction;
        // Link between the gamepad axis and the associated actions.
        std::unordered_multimap<event::Gamepad::Axis, UserActionLink> _gamepadAxisToAction;
        // User profiles.
        std::vector<UserProfile> _users;
 
        friend class UsersTester;
    };
} // namespace ecstasy::integration::user_action
 
#endif /* !ECSTAS_INTEGRATIONS_USER_ACTION_USERS_HPP_ */