SFML Ping Pong improved (V0.3)

#ifndef RESOURCEHOLDER_H
#define RESOURCEHOLDER_H

#include <map>
#include <string>
#include <memory>
#include <stdexcept>
#include <cassert>


template <typename Resource, typename Identifier>
class ResourceHolder
{
public:
    void load(Identifier id, const std::string& filename);

    Resource& get(Identifier id);
    const Resource& get(Identifier id) const;

private:
    void insertResource(Identifier id, std::unique_ptr<Resource> resource);

    std::map<Identifier, std::unique_ptr<Resource>> mResourceMap;
};

#include "ResourceHolder.inl"
#endif // RESOURCEHOLDER_H

template <typename Resource, typename Identifier>
void ResourceHolder<Resource, Identifier>::load(Identifier id, const std::string& filename)
{
    // Create and load resource
    // it seems codeX doesn't support std::make_unique
    std::unique_ptr<Resource> resource(new Resource());
    if (!resource->loadFromFile(filename))
        throw std::runtime_error("ResourceHolder::load - Failed to load " + filename);

    // If loading successful, insert resource to map
    insertResource(id, std::move(resource));
}

template <typename Resource, typename Identifier>
Resource& ResourceHolder<Resource, Identifier>::get(Identifier id)
{
    auto found = mResourceMap.find(id);
    assert(found != mResourceMap.end());

    return *found->second;
}

template <typename Resource, typename Identifier>
const Resource& ResourceHolder<Resource, Identifier>::get(Identifier id) const
{
    auto found = mResourceMap.find(id);
    assert(found != mResourceMap.end());

    return *found->second;
}

template <typename Resource, typename Identifier>
void ResourceHolder<Resource, Identifier>::insertResource(Identifier id, std::unique_ptr<Resource> resource)
{
    // Insert and check success
    auto inserted = mResourceMap.insert(std::make_pair(id, std::move(resource)));
    assert(inserted.second);
}

#ifndef RESOURCEIDENTIFIERS_H
#define RESOURCEIDENTIFIERS_H


// Forward declaration of SFML classes
namespace sf
{
    class SoundBuffer;
}

enum class Sounds
{
    Countdown,
    Start
};

// Forward declaration and a few type definitions
template <typename Resource, typename Identifier>
class ResourceHolder;

using SoundHolder = ResourceHolder<sf::SoundBuffer, Sounds>;

#endif // RESOURCEIDENTIFIERS_H

namespace Screen
{
    enum Size
    {
        Width = 800,
        Height = 600
    };
}

#include <SFML/Graphics.hpp>
#include <SFML/Audio.hpp>
//#include "ResourcePath.hpp"
#include "ResourceHolder.h"
#include "ResourceIdentifiers.h"
#include <cstdint>
#include <iostream>

using std::cout;
using std::endl;

//Version
std::string ver = "V0.3";
//Create Text and font variables
sf::Text text;
sf::Font font;

// for eliminating magic numbers
enum class Players
{
    PlayerOne,
    PlayerTwo
};


namespace Screen
{
    enum Size
    {
        Width = 800,
        Height = 600
    };
}


//Make this class Drawable
class Paddel : public sf::Drawable
{
    // for member data perfered to be started with m prefix
    float mSpeed;
    sf::Vector2f mBorder;
    sf::Vector2f mPosition;
    sf::Vector2u mScreenSize;
    sf::RectangleShape mShape;
public:

    Paddel(Screen::Size screenSize, Players player)
        // member data perfered be initilaized as contructor's initilaized list
        : mScreenSize(Screen::Width, Screen::Height)
        , mBorder(8, 6)
        , mSpeed(5.f)
    {
        sf::Vector2f size = sf::Vector2f(20, 100);

        //Which player
        switch (player)
        {
        case Players::PlayerOne:
            //If player one set position to border
            mPosition = mBorder;
            break;
        default:
            //Else set positionX to (screenWidth - paddelWidth) - borderWidth
            mPosition.x = (mScreenSize.x - size.x) - mBorder.x;
            //positionY = borderY
            mPosition.y = mBorder.y;
        }
        //Set size and position of drawable shape
        mShape.setSize(size);
        mShape.setPosition(mPosition);
    }

    void moveUp()
    {
        //Get closer to 0 (Top of screen)
        mPosition.y -= mSpeed;
        //If gone too far add speed
        if (mPosition.y < mBorder.y)
            mPosition.y += mSpeed;
        mShape.setPosition(mPosition);
    }

    //Do the same opposite way round
    void moveDown()
    {
        mPosition.y += mSpeed;
        if (mPosition.y >(mScreenSize.y - mBorder.y) - mShape.getSize().y)
            mPosition.y -= mSpeed;
        mShape.setPosition(mPosition);
    }

    //Override sf::Drawable function
    void draw(sf::RenderTarget& target, sf::RenderStates) const override
    {
        // sf::RectangleShape has its own defualt RenderStates
        target.draw(mShape); // <-- NOTE : shorter version 
    }
};

int main()
{
    //Initilise screen size and Window
    sf::RenderWindow Window(sf::VideoMode(Screen::Width, Screen::Height), "Ping Pong " + ver, sf::Style::Titlebar | sf::Style::Close);

    //Create Text
    bool enableText = true;
    bool countdown = false;
    // Try to load font resources
    try
    {
        font.loadFromFile(/*resourcePath() +*/ "Pacifico.ttf");
    }
    catch (std::runtime_error& e)
    {
        cout << "Exception: " << e.what() << std::endl;
        enableText = false;
    }

    text.setFont(font);
    text.setCharacterSize(50);
    text.setColor(sf::Color::White);

    //Limit frame rate and enab