Ticket #3806: 3556_dedServer_v1.5.1.patch

File 3556_dedServer_v1.5.1.patch, 18.7 KB (added by Imarok, 8 years ago)

Rename SendKickPlayerMessage, Modify comment and remove the kick/ban LOGERROR

  • binaries/data/mods/public/gui/common/network.js

     
    8989
    9090function kickPlayer(username, ban)
    9191{
    92     if (!Engine.KickPlayer(username, ban))
     92    if (g_IsController)
     93        Engine.KickPlayer(username, ban);
     94    else
    9395        addChatMessage({
    9496            "type": "system",
    9597            "text": sprintf(ban ? translate("Could not ban %(name)s.") : translate("Could not kick %(name)s."), {

  • binaries/data/mods/public/gui/gamesetup/gamesetup.js

     
    670670        return;
    671671
    672672    g_PlayerAssignments[message.guid].status = +message.status == 1;
    673     Engine.SetNetworkPlayerStatus(message.guid, +message.status);
    674673    updateReadyUI();
    675674}
    676675

  • source/gui/scripting/ScriptFunctions.cpp

     
    248248
    249249void StartNetworkGame(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
    250250{
    251     ENSURE(g_NetServer);
    252     g_NetServer->StartGame();
     251    ENSURE(g_NetClient);
     252    g_NetClient->SendStartGameMessage();
    253253}
    254254
    255255void StartGame(ScriptInterface::CxPrivate* pCxPrivate, JS::HandleValue attribs, int playerID)
    … …  
    332332
    333333void SetNetworkGameAttributes(ScriptInterface::CxPrivate* pCxPrivate, JS::HandleValue attribs1)
    334334{
    335     ENSURE(g_NetServer);
     335    ENSURE(g_NetClient);
    336336    //TODO: This is a workaround because we need to pass a MutableHandle to a JSAPI functions somewhere
    337337    // (with no obvious reason).
    338338    JSContext* cx = pCxPrivate->pScriptInterface->GetContext();
    … …  
    339339    JSAutoRequest rq(cx);
    340340    JS::RootedValue attribs(cx, attribs1);
    341341
    342     g_NetServer->UpdateGameAttributes(&attribs, *(pCxPrivate->pScriptInterface));
     342    g_NetClient->SendGameSetupMessage(&attribs, *(pCxPrivate->pScriptInterface));
    343343}
    344344
    345345void StartNetworkHost(ScriptInterface::CxPrivate* pCxPrivate, const std::wstring& playerName)
    … …  
    402402    return g_NetClient->GetGUID();
    403403}
    404404
    405 bool KickPlayer(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const CStrW& playerName, bool ban)
     405void KickPlayer(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const CStrW& playerName, bool ban)
    406406{
    407     if (!g_NetServer)
    408         return false;
    409 
    410     return g_NetServer->KickPlayer(playerName, ban);
     407    ENSURE(g_NetClient);
     408    g_NetClient->SendKickPlayerMessage(playerName, ban);
    411409}
    412410
    413411JS::Value PollNetworkClient(ScriptInterface::CxPrivate* pCxPrivate)
    … …  
    425423
    426424void AssignNetworkPlayer(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int playerID, const std::string& guid)
    427425{
    428     ENSURE(g_NetServer);
     426    ENSURE(g_NetClient);
    429427
    430     g_NetServer->AssignPlayer(playerID, guid);
     428    g_NetClient->SendAssignPlayerMessage(playerID, guid);
    431429}
    432430
    433 void SetNetworkPlayerStatus(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::string& guid, int ready)
    434 {
    435     ENSURE(g_NetServer);
    436 
    437     g_NetServer->SetPlayerReady(guid, ready);
    438 }
    439 
    440431void ClearAllPlayerReady (ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
    441432{
    442     ENSURE(g_NetServer);
     433    ENSURE(g_NetClient);
    443434
    444     g_NetServer->ClearAllPlayerReady();
     435    g_NetClient->SendClearAllReadyMessage();
    445436}
    446437
    447438void SendNetworkChat(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::wstring& message)
    … …  
    10401031    scriptInterface.RegisterFunction<void, std::wstring, std::string, &StartNetworkJoin>("StartNetworkJoin");
    10411032    scriptInterface.RegisterFunction<void, &DisconnectNetworkGame>("DisconnectNetworkGame");
    10421033    scriptInterface.RegisterFunction<std::string, &GetPlayerGUID>("GetPlayerGUID");
    1043     scriptInterface.RegisterFunction<bool, CStrW, bool, &KickPlayer>("KickPlayer");
     1034    scriptInterface.RegisterFunction<void, CStrW, bool, &KickPlayer>("KickPlayer");
    10441035    scriptInterface.RegisterFunction<JS::Value, &PollNetworkClient>("PollNetworkClient");
    10451036    scriptInterface.RegisterFunction<void, JS::HandleValue, &SetNetworkGameAttributes>("SetNetworkGameAttributes");
    10461037    scriptInterface.RegisterFunction<void, int, std::string, &AssignNetworkPlayer>("AssignNetworkPlayer");
    1047     scriptInterface.RegisterFunction<void, std::string, int, &SetNetworkPlayerStatus>("SetNetworkPlayerStatus");
    10481038    scriptInterface.RegisterFunction<void, &ClearAllPlayerReady>("ClearAllPlayerReady");
    10491039    scriptInterface.RegisterFunction<void, std::wstring, &SendNetworkChat>("SendNetworkChat");
    10501040    scriptInterface.RegisterFunction<void, int, &SendNetworkReady>("SendNetworkReady");

  • source/network/NetClient.cpp

     
    323323    SetCurrState(NCS_UNCONNECTED);
    324324}
    325325
     326void CNetClient::SendGameSetupMessage(JS::MutableHandleValue attrs, ScriptInterface& scriptInterface)
     327{
     328    JSContext* cx = scriptInterface.GetContext();
     329    JS::RootedValue attrsRooted(cx);
     330    attrsRooted = attrs;
     331
     332    CGameSetupMessage gameSetup(scriptInterface);
     333    gameSetup.m_Data = attrsRooted;
     334    SendMessage(&gameSetup);
     335}
     336
     337void CNetClient::SendAssignPlayerMessage(const int playerID, const CStr& guid)
     338{
     339    CAssignPlayerMessage assignPlayer;
     340    assignPlayer.m_PlayerID = playerID;
     341    assignPlayer.m_GUID = guid;
     342    SendMessage(&assignPlayer);
     343}
     344
    326345void CNetClient::SendChatMessage(const std::wstring& text)
    327346{
    328347    CChatMessage chat;
    … …  
    337356    SendMessage(&readyStatus);
    338357}
    339358
     359void CNetClient::SendClearAllReadyMessage()
     360{
     361    CClearAllReadyMessage clearAllReady;
     362    SendMessage(&clearAllReady);
     363}
     364
     365void CNetClient::SendStartGameMessage()
     366{
     367    CGameStartMessage gameStart;
     368    SendMessage(&gameStart);
     369}
     370
    340371void CNetClient::SendRejoinedMessage()
    341372{
    342373    CRejoinedMessage rejoinedMessage;
    … …  
    343374    SendMessage(&rejoinedMessage);
    344375}
    345376
     377void CNetClient::SendKickPlayerMessage(const CStrW& playerName, bool ban)
     378{
     379    CKickedMessage kickPlayer;
     380    kickPlayer.m_Name = playerName;
     381    kickPlayer.m_Ban = ban;
     382    SendMessage(&kickPlayer);
     383}
     384
    346385void CNetClient::SendPausedMessage(bool pause)
    347386{
    348387    CClientPausedMessage pausedMessage;

  • source/network/NetClient.h

     
    187187     */
    188188    void LoadFinished();
    189189
     190    void SendGameSetupMessage(JS::MutableHandleValue attrs, ScriptInterface& scriptInterface);
     191
     192    void SendAssignPlayerMessage(const int playerID, const CStr& guid);
     193
    190194    void SendChatMessage(const std::wstring& text);
    191195
    192196    void SendReadyMessage(const int status);
    193197
     198    void SendClearAllReadyMessage();
     199
     200    void SendStartGameMessage();
     201
    194202    /**
    195203     * Call when the client has rejoined a running match and finished
    196204     * the loading screen.
    … …  
    198206    void SendRejoinedMessage();
    199207
    200208    /**
     209     * Call to kick/ban a client
     210     */
     211    void SendKickPlayerMessage(const CStrW& playerName, bool ban);
     212
     213    /**
    201214     * Call when the client has paused or unpaused the game.
    202215     */
    203216    void SendPausedMessage(bool pause);

  • source/network/NetMessage.cpp

     
    203203        pNewMessage = new CSimulationMessage(scriptInterface);
    204204        break;
    205205
     206    case NMT_CLEAR_ALL_READY:
     207        pNewMessage = new CClearAllReadyMessage;
     208        break;
     209
     210    case NMT_ASSIGN_PLAYER:
     211        pNewMessage = new CAssignPlayerMessage;
     212        break;
     213
    206214    default:
    207215        LOGERROR("CNetMessageFactory::CreateMessage(): Unknown message type '%d' received", header.GetType());
    208216        break;

  • source/network/NetMessages.h

     
    2828
    2929#define PS_PROTOCOL_MAGIC               0x5073013f      // 'P', 's', 0x01, '?'
    3030#define PS_PROTOCOL_MAGIC_RESPONSE      0x50630121      // 'P', 'c', 0x01, '!'
    31 #define PS_PROTOCOL_VERSION             0x01010013      // Arbitrary protocol
     31#define PS_PROTOCOL_VERSION             0x01010014      // Arbitrary protocol
    3232#define PS_DEFAULT_PORT                 0x5073          // 'P', 's'
    3333
    3434// Defines the list of message types. The order of the list must not change.
    … …  
    5050
    5151    NMT_CHAT,
    5252    NMT_READY,
     53    NMT_CLEAR_ALL_READY,
    5354    NMT_GAME_SETUP,
     55    NMT_ASSIGN_PLAYER,
    5456    NMT_PLAYER_ASSIGNMENT,
    5557
    5658    NMT_FILE_TRANSFER_REQUEST,
    … …  
    136138    NMT_FIELD_INT(m_Status, u8, 1)
    137139END_NMT_CLASS()
    138140
     141START_NMT_CLASS_(ClearAllReady, NMT_CLEAR_ALL_READY)
     142END_NMT_CLASS()
     143
    139144START_NMT_CLASS_(PlayerAssignment, NMT_PLAYER_ASSIGNMENT)
    140145    NMT_START_ARRAY(m_Hosts)
    141146        NMT_FIELD(CStr, m_GUID)
    … …  
    218223    NMT_END_ARRAY()
    219224END_NMT_CLASS()
    220225
     226START_NMT_CLASS_(AssignPlayer, NMT_ASSIGN_PLAYER)
     227    NMT_FIELD_INT(m_PlayerID, i8, 1)
     228    NMT_FIELD(CStr, m_GUID)
     229END_NMT_CLASS()
     230
    221231END_NMTS()
    222232
    223233#else

  • source/network/NetServer.cpp

     
    404404    JSContext* cx = m_ScriptInterface->GetContext();
    405405    JSAutoRequest rq(cx);
    406406
    407     std::vector<std::pair<int, CStr>> newAssignPlayer;
    408407    std::vector<bool> newStartGame;
    409     std::vector<std::pair<CStr, int>> newPlayerReady;
    410     std::vector<bool> newPlayerResetReady;
    411408    std::vector<std::string> newGameAttributes;
    412409    std::vector<u32> newTurnLength;
    413410
    … …  
    418415            return false;
    419416
    420417        newStartGame.swap(m_StartGameQueue);
    421         newPlayerReady.swap(m_PlayerReadyQueue);
    422         newPlayerResetReady.swap(m_PlayerResetReadyQueue);
    423         newAssignPlayer.swap(m_AssignPlayerQueue);
    424418        newGameAttributes.swap(m_GameAttributesQueue);
    425419        newTurnLength.swap(m_TurnLengthQueue);
    426420    }
    427421
    428     for (const std::pair<int, CStr8>& p : newAssignPlayer)
    429         AssignPlayer(p.first, p.second);
    430 
    431     for (const std::pair<CStr8, int>& p : newPlayerReady)
    432         SetPlayerReady(p.first, p.second);
    433 
    434     if (!newPlayerResetReady.empty())
    435         ClearAllPlayerReady();
    436 
    437422    if (!newGameAttributes.empty())
    438423    {
    439424        JS::RootedValue gameAttributesVal(cx);
    … …  
    649634    session->AddTransition(NSS_PREGAME, (uint)NMT_CONNECTION_LOST, NSS_UNCONNECTED, (void*)&OnDisconnect, context);
    650635    session->AddTransition(NSS_PREGAME, (uint)NMT_CHAT, NSS_PREGAME, (void*)&OnChat, context);
    651636    session->AddTransition(NSS_PREGAME, (uint)NMT_READY, NSS_PREGAME, (void*)&OnReady, context);
     637    session->AddTransition(NSS_PREGAME, (uint)NMT_CLEAR_ALL_READY, NSS_PREGAME, (void*)&OnClearAllReady, context);
     638    session->AddTransition(NSS_PREGAME, (uint)NMT_GAME_SETUP, NSS_PREGAME, (void*)&OnGameSetup, context);
     639    session->AddTransition(NSS_PREGAME, (uint)NMT_ASSIGN_PLAYER, NSS_PREGAME, (void*)&OnAssignPlayer, context);
     640    session->AddTransition(NSS_PREGAME, (uint)NMT_KICKED, NSS_PREGAME, (void*)&OnKickPlayer, context);
     641    session->AddTransition(NSS_PREGAME, (uint)NMT_GAME_START, NSS_PREGAME, (void*)&OnStartGame, context);
    652642    session->AddTransition(NSS_PREGAME, (uint)NMT_LOADED_GAME, NSS_INGAME, (void*)&OnLoadedGame, context);
    653643
     644    session->AddTransition(NSS_JOIN_SYNCING, (uint)NMT_KICKED, NSS_JOIN_SYNCING, (void*)&OnKickPlayer, context);
    654645    session->AddTransition(NSS_JOIN_SYNCING, (uint)NMT_CONNECTION_LOST, NSS_UNCONNECTED, (void*)&OnDisconnect, context);
    655646    session->AddTransition(NSS_JOIN_SYNCING, (uint)NMT_LOADED_GAME, NSS_INGAME, (void*)&OnJoinSyncingLoadedGame, context);
    656647
    657648    session->AddTransition(NSS_INGAME, (uint)NMT_REJOINED, NSS_INGAME, (void*)&OnRejoined, context);
     649    session->AddTransition(NSS_INGAME, (uint)NMT_KICKED, NSS_INGAME, (void*)&OnKickPlayer, context);
    658650    session->AddTransition(NSS_INGAME, (uint)NMT_CLIENT_PAUSED, NSS_INGAME, (void*)&OnClientPaused, context);
    659651    session->AddTransition(NSS_INGAME, (uint)NMT_CONNECTION_LOST, NSS_UNCONNECTED, (void*)&OnDisconnect, context);
    660652    session->AddTransition(NSS_INGAME, (uint)NMT_CHAT, NSS_INGAME, (void*)&OnChat, context);
    … …  
    784776    SendPlayerAssignments();
    785777}
    786778
    787 bool CNetServerWorker::KickPlayer(const CStrW& playerName, const bool ban)
     779void CNetServerWorker::KickPlayer(const CStrW& playerName, const bool ban)
    788780{
    789781    // Find the user with that name
    790782    std::vector<CNetServerSession*>::iterator it = std::find_if(m_Sessions.begin(), m_Sessions.end(),
    … …  
    792784
    793785    // and return if no one or the host has that name
    794786    if (it == m_Sessions.end() || (*it)->GetGUID() == m_HostGUID)
    795         return false;
     787        return;
    796788
    797789    if (ban)
    798790    {
    … …  
    814806    kickedMessage.m_Name = playerName;
    815807    kickedMessage.m_Ban = ban;
    816808    Broadcast(&kickedMessage);
    817 
    818     return true;
    819809}
    820810
    821811void CNetServerWorker::AssignPlayer(int playerID, const CStr& guid)
    … …  
    11081098    message->m_GUID = session->GetGUID();
    11091099
    11101100    server.Broadcast(message);
     1101    server.SetPlayerReady(message->m_GUID, message->m_Status);
    11111102
    11121103    return true;
    11131104}
    11141105
     1106bool CNetServerWorker::OnClearAllReady(void* context, CFsmEvent* event)
     1107{
     1108    ENSURE(event->GetType() == (uint)NMT_CLEAR_ALL_READY);
     1109
     1110    CNetServerSession* session = (CNetServerSession*)context;
     1111    CNetServerWorker& server = session->GetServer();
     1112
     1113    if (session->GetGUID() == server.m_HostGUID)
     1114        server.ClearAllPlayerReady();
     1115
     1116    return true;
     1117}
     1118
     1119bool CNetServerWorker::OnGameSetup(void* context, CFsmEvent* event)
     1120{
     1121    ENSURE(event->GetType() == (uint)NMT_GAME_SETUP);
     1122
     1123    CNetServerSession* session = (CNetServerSession*)context;
     1124    CNetServerWorker& server = session->GetServer();
     1125
     1126    if (session->GetGUID() == server.m_HostGUID)
     1127    {
     1128        CGameSetupMessage* message = (CGameSetupMessage*)event->GetParamRef();
     1129        server.UpdateGameAttributes(&(message->m_Data));
     1130    }
     1131    return true;
     1132}
     1133
     1134bool CNetServerWorker::OnAssignPlayer(void* context, CFsmEvent* event)
     1135{
     1136    ENSURE(event->GetType() == (uint)NMT_ASSIGN_PLAYER);
     1137    CNetServerSession* session = (CNetServerSession*)context;
     1138    CNetServerWorker& server = session->GetServer();
     1139
     1140    if (session->GetGUID() == server.m_HostGUID)
     1141    {
     1142        CAssignPlayerMessage* message = (CAssignPlayerMessage*)event->GetParamRef();
     1143        server.AssignPlayer(message->m_PlayerID, message->m_GUID);
     1144    }
     1145    return true;
     1146}
     1147
     1148bool CNetServerWorker::OnStartGame(void* context, CFsmEvent* event)
     1149{
     1150    ENSURE(event->GetType() == (uint)NMT_GAME_START);
     1151    CNetServerSession* session = (CNetServerSession*)context;
     1152    CNetServerWorker& server = session->GetServer();
     1153
     1154    if (session->GetGUID() == server.m_HostGUID)
     1155        server.StartGame();
     1156
     1157    return true;
     1158}
     1159
    11151160bool CNetServerWorker::OnLoadedGame(void* context, CFsmEvent* event)
    11161161{
    11171162    ENSURE(event->GetType() == (uint)NMT_LOADED_GAME);
    … …  
    12041249    return true;
    12051250}
    12061251
     1252bool CNetServerWorker::OnKickPlayer(void* context, CFsmEvent* event)
     1253{
     1254    ENSURE(event->GetType() == (uint)NMT_KICKED);
     1255
     1256    CNetServerSession* session = (CNetServerSession*)context;
     1257    CNetServerWorker& server = session->GetServer();
     1258
     1259    if (session->GetGUID() == server.m_HostGUID)
     1260    {
     1261        CKickedMessage* message = (CKickedMessage*)event->GetParamRef();
     1262        server.KickPlayer(message->m_Name, message->m_Ban);
     1263    }
     1264    return true;
     1265}
     1266
    12071267bool CNetServerWorker::OnDisconnect(void* context, CFsmEvent* event)
    12081268{
    12091269    ENSURE(event->GetType() == (uint)NMT_CONNECTION_LOST);
    … …  
    13721432    return m_Worker->SetupConnection();
    13731433}
    13741434
    1375 bool CNetServer::KickPlayer(const CStrW& playerName, const bool ban)
    1376 {
    1377     CScopeLock lock(m_Worker->m_WorkerMutex);
    1378     return m_Worker->KickPlayer(playerName, ban);
    1379 }
    1380 
    1381 void CNetServer::AssignPlayer(int playerID, const CStr& guid)
    1382 {
    1383     CScopeLock lock(m_Worker->m_WorkerMutex);
    1384     m_Worker->m_AssignPlayerQueue.emplace_back(playerID, guid);
    1385 }
    1386 
    1387 void CNetServer::SetPlayerReady(const CStr& guid, int ready)
    1388 {
    1389     CScopeLock lock(m_Worker->m_WorkerMutex);
    1390     m_Worker->m_PlayerReadyQueue.emplace_back(guid, ready);
    1391 }
    1392 
    1393 void CNetServer::ClearAllPlayerReady()
    1394 {
    1395     CScopeLock lock(m_Worker->m_WorkerMutex);
    1396     m_Worker->m_PlayerResetReadyQueue.push_back(false);
    1397 }
    1398 
    13991435void CNetServer::StartGame()
    14001436{
    14011437    CScopeLock lock(m_Worker->m_WorkerMutex);

  • source/network/NetServer.h

     
    116116    bool SetupConnection();
    117117
    118118    /**
    119      * Call from the GUI to update the player assignments.
    120      * The given GUID will be (re)assigned to the given player ID.
    121      * Any player currently using that ID will be unassigned.
    122      * The changes will be asynchronously propagated to all clients.
    123      */
    124     void AssignPlayer(int playerID, const CStr& guid);
    125 
    126     /**
    127      * Call from the GUI to update the player readiness.
    128      * The changes will be asynchronously propagated to all clients.
    129      */
    130     void SetPlayerReady(const CStr& guid, int ready);
    131 
    132     /**
    133      * Call from the GUI to set the all player readiness to 0.
    134      * The changes will be asynchronously propagated to all clients.
    135      */
    136     void ClearAllPlayerReady();
    137 
    138     /**
    139      * Disconnects a player from gamesetup or session.
    140      */
    141     bool KickPlayer(const CStrW& playerName, const bool ban);
    142 
    143     /**
    144119     * Call from the GUI to asynchronously notify all clients that they should start loading the game.
    145120     */
    146121    void StartGame();
    … …  
    190165    /**
    191166     * Disconnects a player from gamesetup or session.
    192167     */
    193     bool KickPlayer(const CStrW& playerName, const bool ban);
     168    void KickPlayer(const CStrW& playerName, const bool ban);
    194169
    195170    /**
    196171     * Send a message to all clients who have completed the full connection process
    … …  
    270245    static bool OnInGame(void* context, CFsmEvent* event);
    271246    static bool OnChat(void* context, CFsmEvent* event);
    272247    static bool OnReady(void* context, CFsmEvent* event);
     248    static bool OnClearAllReady(void* context, CFsmEvent* event);
     249    static bool OnGameSetup(void* context, CFsmEvent* event);
     250    static bool OnAssignPlayer(void* context, CFsmEvent* event);
     251    static bool OnStartGame(void* context, CFsmEvent* event);
    273252    static bool OnLoadedGame(void* context, CFsmEvent* event);
    274253    static bool OnJoinSyncingLoadedGame(void* context, CFsmEvent* event);
    275254    static bool OnRejoined(void* context, CFsmEvent* event);
     255    static bool OnKickPlayer(void* context, CFsmEvent* event);
    276256    static bool OnDisconnect(void* context, CFsmEvent* event);
    277257    static bool OnClientPaused(void* context, CFsmEvent* event);
    278258
    … …  
    367347    bool m_Shutdown; // protected by m_WorkerMutex
    368348
    369349    // Queues for messages sent by the game thread:
    370     std::vector<std::pair<int, CStr>> m_AssignPlayerQueue; // protected by m_WorkerMutex
    371350    std::vector<bool> m_StartGameQueue; // protected by m_WorkerMutex
    372     std::vector<std::pair<CStr, int>> m_PlayerReadyQueue; // protected by m_WorkerMutex
    373     std::vector<bool> m_PlayerResetReadyQueue; // protected by m_WorkerMutex
    374351    std::vector<std::string> m_GameAttributesQueue; // protected by m_WorkerMutex
    375352    std::vector<u32> m_TurnLengthQueue; // protected by m_WorkerMutex
    376353};