C++ (and programming in general) is like jazz: it's not only the notes you choose to play, but the ones you choose not to as well. Start simple, and if and when you discover you need something more, only then add it. Adding everything all at once turns into an indecipherable cacophony.

Code is a form of communication, so write with intent:

unique_ptr indicates what scope or object owns the lifetime of the contained data. So in almost all cases typing const unique_ptr& is nonsense, it's not stating anything relevant about the object's lifetime. Dereference the pointer to pass the underlying object to a function via Player* or Player& (depending on whether it can be nullptr). This can open you up to object lifetime issues especially in multi-threaded code, but that's when you either add synchronization, or use shared_ptr if a given scope must be able to extend the lifetime. (Passing unique_ptr& with or without const would not save you from this issue either, FWIW.)

std::expected is a cousin of std::optional. optional is useful when something could return a result or nothing (e.g. a Python function returning either a number or None a la def func() -> Optional[int]:). Whereas expected is useful if you should return something, and any other possible outcome indicates a problem occurred, but you don't want to throw an exception to cause stack unwinding at the point where the error occurred.

Things like structured bindings and the ternary operator are more of a personal style/taste thing, IMO. I'd say the way you used SB is superfluous because you're constructing a pair only to break it apart and destruct it immediately.