Random number generation in Dice class
Just based on the code, and in no particular order:


Bikeshedding: as Dice represents a single die, I would call it such.
You're passing Dice by reference to const everywhere.  In your current design it is just an int, and I don't see anything happening that would increase the cost of passing it significantly, or cause it to become non-copyable.  As per Optimizing Emergent Structures in C++ you should prefer to pass by value here.
Your rd, gen, and dis should all be in an anonymous namespace to prevent linker errors when people define things of the same name in other files.
Does equality and inequality really make sense here?  It bothers me that x == y is not preserved after x.roll(); y.roll();.  I think I'd stick to accessing value explicitly, and not allow equality on Dice.


As for design: the implicit sharing of state between dice bothers me.  It isn't detectable as-is, but it means that there is no way of specifying that a particular die will return particular results (for debugging).  If this is used in a multithread application, the results of roll may be surprising; I'm fairly sure uniform_int_distribution&lt;&gt;::operator() should not be called from multiple threads at once.

I think I'd go for the more explicit approach of having an updateRandom and getRandom pair, or ensure thread-safety of roll.

You could also make this more generic:

// die.hpp
extern std::random_device rd;
extern std::mt19937 gen;

template&lt;typename T&gt;
struct Die {
    T value() const {
        return topValue;
    }

    void roll() {
        topValue = dis(gen);
    }

private:
    T topValue;
    static std::uniform_int_distribution&lt;T&gt; dis;
};

template&lt;typename T&gt;
std::uniform_int_distribution&lt;T&gt; Die&lt;T&gt;::dis(1, 6);

// die.cpp
std::random_device rd;
std::mt19937 gen(rd());


However, this would have the obvious drawback of the implementation being exposed.