Jak wysyłać odpowiednie dane do odpowiedniej zmiennej?

Witam, od 9 godzin siedzie i myśle jak to zrobić. Jak zrobić że jak gracz dołącza to zmienna klient zwiększa się w górę i służy jako tablica np: X[klient], Y[klient], Z[klient] ( to mam ) i chce by np gracz dziesiąty wysyłał swoje położenie i kont i by one nadpisywały się;

NWM czy zrozumiale wytłumaczyłem o co mi chodzi.

Jeśli potrzebujesz mieć zbiór klientów, to po prostu użyj vector'a, do którego będziesz mógł wrzucać nowo utworzonych (dołączonych) klientów:

void Server::OnClientConnectedCb( /*client parameters - if any*/ )
{
    this->clients.emplace_back( std::make_shared<Client>( /*client parameters - if any*/ );
}

Dzięki temu od razu masz informację ile jest klientów:

void Server::ShowAmountOfClientsInServer( void )
{
    std::cout << "Current amount of clients: " << clients.size() << std::endl;
}

edit: Doprecyzuję - vector to dynamiczna "tablica", z której możesz pobierać elementy tak samo jak chciałeś wcześniej: clients[ clientID ] lub poprzez lepszą alternatywę: clients.at( clientID ). Zwróci Ci to wskaźnik na wybranego klienta, z którym będziesz już mógł zrobić co zechcesz.
Zauważ też, że nie korzystam już ze zmiennej klient, bo informację o rozmiarze już mam wykorzystując pokazane wcześniej clients.size()

Nie rozumiem jednak tego zapisu:

X[klient], Y[klient], Z[klient]

To wygląda jakbyś miał trzy tablice, z których chcesz wyciągnąć coś o indeksie klient. Możesz to doprecyzować, bo nie wiem czy pomogłem z Twoim problemem?

Stworzyłem 3 tablice i chciałbym by odpowiedni klient np client 1 mógł nadpisywać tablice[1],a np. client 30 mógł nadpisać tablice[30]

float PlayerAngleS[klient];
float PlayerPosSX[klient];
float PlayerPosSY[klient];

W takim razie nie ma problemu, jeśli założysz, że klient jest konkretnym bytem (klasą) i ma swoje pole mówiące o przydzielonym mu indeksie tablicy, jaką ma modyfikować.
Już pokazuję kod:

// Mamy gracza jako klasę:
class Player
{
public:
    Player( const unsigned int arrayNumber ) : m_arrayNumber( arrayNumber ) { }
    const unsigned int GetArrayNumber( void ) const { return m_arrayNumber; }
private:
    unsigned int m_arrayNumber;
}

// Teraz mając instancję gracza możemy wprost odwołać się do przydzielonej mu tablicy:
int main( void )
{
    Player player( 3 );
    // Mamy też tablicę tablic, które przydzielone będą graczom:
    float gameArrays[30][30];
    
    // Nie wiem co chcesz robić z tablicami, ale tutaj przykład w jaki odwołujemy się do przydzielonej tablicy:
    gameArrays[ player.GetArrayNumber() ];

To tylko przykład, dużo w nim założeń (na przykład rozmiary tablic i ich liczba), tak samo uzyskana tablica z gameArrays powinna być gdzieś pobierana, lub coś powinno się tam dziać, ale myślę, że załapiesz obraz.

Chyba widzę o co dokładnie Ci chodzi i mam wrażenie, że męczysz się z tym, ponieważ źle do tego podchodzisz.
To co Ty chcesz uzyskać, to informacje o graczu, które on będzie mógł modyfikować. W porządku. Problem jednak w tym, że obecnie każdą taką informację przechowujesz w oddzielnej tablicy. Tworzysz więc tablicę tej samej informacji ale dla każdego gracza osobno.

Pójdź w zupełnie innym kierunku. Niech to gracz (w swojej klasie) przechowuje te informacje. Napisz metody udostępniające te informacje (jak położenie X, Y). Nie będziesz wtedy potrzebował tylu tablic.

edit: Dam też przykład:

class Player
{
public:
    // The modifiers of player status and parameters
    void MoveUp( void ) { m_PositionY++; }
    void MoveDown( void ) { m_PositionY++; }
    void MoveLeft( void ) { m_PositionX--; }
    void MoveRight( void ) { m_PositionX++; }

    // Getters of player status and parameters
    std::pair<float, float> GetPosition( void ) { return {m_PositionX, m_PositionY}; }

private:
    float m_PositionX;
    float m_PositionY;

    // Here can be placed the rest of desired parameters...
}

edit2: Jeśli chodzi o metodę MoveDown to inkrementuje ona m_PositionY ponieważ w oknie SFML'a punkt 0,0 znajduje się w lewym górnym rogu. Prawy dolny róg to Rozmiar,Rozmiar. Stąd inkrementacja.

Chodzi mi o to że pobieram te wartości i przesyłam do serwera do tablic i każda tablica jest przypisana do go odpowiedniego gracza

Więc jeśli nadal nie pomogłem i nie odpowiedziałem na Twoje pytanie/problem to możesz połączyć wszystko co napisałem i zamieścić w klasie gracza pole przechowujące indeks lub inne oznaczenie przypisanej mu tablicy.
Wciąż uważam, że gdzieś założona przez Ciebie architektura jest zaprojektowana błędnie, ale jeśli tym razem dobrze rozumiem Twój problem, to proponuję coś w tym stylu:

class Server
{
public:
    void RegisterNewPlayer( const Player& newPlayer );
    void GetPlayerPosition( const unsigned int playerID, std::pair<float,float> playerPosition )
    {
        PlayerPosSX[ playerID ] = playerPosition.first;
        PlayerPosSY[ playerID ] = playerPosition.second;
    }

    // And so on with other data like angle and etc...

private:
    float PlayerPosSX[klient];
    float PlayerPosSY[klient];
}

edit: To co wyżej, stanowi rozwiązanie idące Twoim tokiem i zgodne z założoną przez Ciebie architekturą. Ja uważam jednak, że da się to zrobić inaczej, prościej.
Niech serwer przechowuje graczy w vectorze. Jeśli będą one współdzielonymi wskaźnikami będziesz miał wygodne rozwiązanie pozwalające Ci uniknąć ciągłego wywoływania metod pobierających osobno położenie, prędkość, kąt i wszystkie inne jakie sobie założyłeś.
Przykład tego o czym mówię:

class Server
{
public:
    void RegisterNewPlayer( std::shared_ptr<Player> newPlayer )
    {
        players.push_back( newPlayer );
    }

    // Getters of all the players data could be safely removed
private:
    std::vector<std::shared_ptr<Player >> players;
}

To jest to. Dziękuje.