Merge pull request #1 from ilikepizza107/master

Default to the traversal server

Author: Motobug

Data/user/Config/Dolphin.ini

@@ -7,3 +7,4 @@ ISOPath0 = ./Launcher
 ISOPath1 = ./Games
 [NetPlay]
 SelectedHostGame = Project+ Netplay Launcher.elf
+TraversalChoice = traversal

Source/Core/Core/Config/NetplaySettings.cpp

@@ -43,7 +43,8 @@ const Info<bool> NETPLAY_ENABLE_CHUNKED_UPLOAD_LIMIT{
     {System::Main, "NetPlay", "EnableChunkedUploadLimit"}, false};
 const Info<u32> NETPLAY_CHUNKED_UPLOAD_LIMIT{{System::Main, "NetPlay", "ChunkedUploadLimit"}, 3000};
 
-const Info<u32> NETPLAY_BUFFER_SIZE{{System::Main, "NetPlay", "BufferSize"}, 2};
+const Info<u32> NETPLAY_MINIMUM_BUFFER_SIZE{{System::Main, "NetPlay", "MinimumBufferSize"}, 2};
+const Info<u32> NETPLAY_PLAYER_BUFFER_SIZE{{System::Main, "NetPlay", "PlayerBufferSize"}, 2};
 const Info<u32> NETPLAY_CLIENT_BUFFER_SIZE{{System::Main, "NetPlay", "BufferSizeClient"}, 1};
 
 const Info<bool> NETPLAY_SAVEDATA_LOAD{{System::Main, "NetPlay", "SyncSaves"}, true};

Source/Core/Core/Config/NetplaySettings.h

@@ -39,7 +39,8 @@ extern const Info<std::string> NETPLAY_INDEX_PASSWORD;
 extern const Info<bool> NETPLAY_ENABLE_CHUNKED_UPLOAD_LIMIT;
 extern const Info<u32> NETPLAY_CHUNKED_UPLOAD_LIMIT;
 
-extern const Info<u32> NETPLAY_BUFFER_SIZE;
+extern const Info<u32> NETPLAY_MINIMUM_BUFFER_SIZE;
+extern const Info<u32> NETPLAY_PLAYER_BUFFER_SIZE;
 extern const Info<u32> NETPLAY_CLIENT_BUFFER_SIZE;
 
 extern const Info<bool> NETPLAY_SAVEDATA_LOAD;

Source/Core/Core/NetPlayClient.cpp

@@ -41,6 +41,7 @@
 #include "Core/Config/SessionSettings.h"
 #include "Core/Config/WiimoteSettings.h"
 #include "Core/ConfigManager.h"
+#include "Core/Core.h"
 #include "Core/GeckoCode.h"
 #include "Core/HW/EXI/EXI.h"
 #include "Core/HW/EXI/EXI_DeviceIPL.h"
@@ -82,7 +83,7 @@ namespace NetPlay
 using namespace WiimoteCommon;
 
 static std::mutex crit_netplay_client;
-static NetPlayClient* netplay_client = nullptr;
+NetPlayClient* netplay_client = nullptr;
 static bool s_si_poll_batching = false;
 
 // called from ---GUI--- thread
@@ -309,6 +310,7 @@ bool NetPlayClient::Connect()
     player.name = m_player_name;
     player.pid = m_pid;
     player.revision = Common::GetNetplayDolphinVer();
+    player.buffer = 0 /* will be raised once we get the packet */;
 
     // add self to player list
     m_players[m_pid] = player;
@@ -322,6 +324,31 @@ bool NetPlayClient::Connect()
   }
 }
 
+// called from ---GUI--- and ---NETPLAY--- thread
+void NetPlayClient::AdjustPlayerPadBufferSize(u32 buffer)
+{
+  std::lock_guard<std::recursive_mutex> lkp(m_crit.players);
+
+  m_local_player->buffer = buffer;
+  if (m_local_player->buffer < m_minimum_buffer_size)
+    m_local_player->buffer = m_minimum_buffer_size;
+  
+  // need to rewrite this area
+  
+  /* auto spac = std::make_unique<sf::Packet>();
+  *spac << static_cast <MessageID>(OnPadBufferPlayer);
+  *spac << local_player->buffer;
+  SendAsync(std::move(spac)); */ 
+
+  m_dialog->OnPlayerPadBufferChanged(m_local_player->buffer);
+}
+
+void NetPlayClient::AdjustMinimumPadBufferSize(const unsigned int size)
+{
+  m_minimum_buffer_size = size;
+  m_dialog->OnMinimumPadBufferChanged(size);
+}
+
 static void ReceiveSyncIdentifier(sf::Packet& spac, SyncIdentifier& sync_identifier)
 {
   // We use a temporary variable here due to a potential long vs long long mismatch
@@ -400,8 +427,12 @@ void NetPlayClient::OnData(sf::Packet& packet)
     OnWiimoteData(packet);
     break;
 
-  case MessageID::PadBuffer:
-    OnPadBuffer(packet);
+  case MessageID::PadBufferMinimum:
+    OnPadBufferMinimum(packet);
+    break;
+    
+  case MessageID::PadBufferPlayer:
+    OnPadBufferPlayer(packet);
     break;
 
   case MessageID::HostInputAuthority:
@@ -751,13 +782,28 @@ void NetPlayClient::OnWiimoteData(sf::Packet& packet)
   }
 }
 
-void NetPlayClient::OnPadBuffer(sf::Packet& packet)
+void NetPlayClient::OnPadBufferMinimum(sf::Packet& packet)
 {
   u32 size = 0;
   packet >> size;
+  
+  m_minimum_buffer_size = size;
+    m_dialog->OnMinimumPadBufferChanged(size);
 
-  m_target_buffer_size = size;
-  m_dialog->OnPadBufferChanged(size);
+    if (m_local_player->buffer < m_minimum_buffer_size)
+      AdjustPlayerPadBufferSize(m_minimum_buffer_size);
+}
+
+
+void NetPlayClient::OnPadBufferPlayer(sf::Packet& packet)
+{
+    PlayerId pid;
+    packet >> pid;
+
+    {
+      std::lock_guard<std::recursive_mutex> lkp(m_crit.players);
+      packet >> m_players[pid].buffer;
+    }
 }
 
 void NetPlayClient::OnHostInputAuthority(sf::Packet& packet)
@@ -2084,7 +2130,7 @@ bool NetPlayClient::GetNetPads(const int pad_nb, const bool batching, GCPadStatu
       // we toggle the emulation speed too quickly, so to prevent this
       // we wait until the buffer has been over for at least 1 second.
 
-      const bool buffer_over_target = m_pad_buffer[pad_nb].Size() > m_target_buffer_size + 1;
+      const bool buffer_over_target = m_pad_buffer[pad_nb].Size() > m_minimum_buffer_size + 1;
       if (!buffer_over_target)
         m_buffer_under_target_last = std::chrono::steady_clock::now();
 
@@ -2214,7 +2260,7 @@ bool NetPlayClient::PollLocalPad(const int local_pad, sf::Packet& packet)
   {
     // adjust the buffer either up or down
     // inserting multiple padstates or dropping states
-    while (m_pad_buffer[ingame_pad].Size() <= m_target_buffer_size)
+    while (m_pad_buffer[ingame_pad].Size() <= m_minimum_buffer_size)
     {
       // add to buffer
       m_pad_buffer[ingame_pad].Push(pad_status);
@@ -2237,7 +2283,7 @@ bool NetPlayClient::AddLocalWiimoteToBuffer(const int local_wiimote,
 
   // adjust the buffer either up or down
   // inserting multiple padstates or dropping states
-  while (m_wiimote_buffer[ingame_pad].Size() <= m_target_buffer_size)
+  while (m_wiimote_buffer[ingame_pad].Size() <= m_minimum_buffer_size)
   {
     // add to buffer
     m_wiimote_buffer[ingame_pad].Push(state);
@@ -2636,12 +2682,6 @@ const PadMappingArray& NetPlayClient::GetWiimoteMapping() const
   return m_wiimote_map;
 }
 
-void NetPlayClient::AdjustPadBufferSize(const unsigned int size)
-{
-  m_target_buffer_size = size;
-  m_dialog->OnPadBufferChanged(size);
-}
-
 void NetPlayClient::SetWiiSyncData(std::unique_ptr<IOS::HLE::FS::FileSystem> fs,
                                    std::vector<u64> titles, std::string redirect_folder)
 {

Source/Core/Core/NetPlayClient.h

@@ -63,7 +63,8 @@ class NetPlayUI
   virtual void OnMsgPowerButton() = 0;
   virtual void OnPlayerConnect(const std::string& player) = 0;
   virtual void OnPlayerDisconnect(const std::string& player) = 0;
-  virtual void OnPadBufferChanged(u32 buffer) = 0;
+  virtual void OnMinimumPadBufferChanged(u32 buffer) = 0;
+  virtual void OnPlayerPadBufferChanged(u32 buffer) = 0;
   virtual void OnHostInputAuthorityChanged(bool enabled) = 0;
   virtual void OnDesync(u32 frame, const std::string& player) = 0;
   virtual void OnConnectionLost() = 0;
@@ -103,6 +104,7 @@ class Player
   std::string name;
   std::string revision;
   u32 ping = 0;
+  u32 buffer = 0;
   SyncIdentifierComparison game_status = SyncIdentifierComparison::Unknown;
 
   bool IsHost() const { return pid == 1; }
@@ -167,12 +169,40 @@ class NetPlayClient : public Common::TraversalClientClient
 
   static void SendTimeBase();
   bool DoAllPlayersHaveGame();
+  
+  void AdjustPlayerPadBufferSize(u32 buffer);
+
+  // the number of ticks in-between frames
+  constexpr static int buffer_accuracy = 4;
+
+  inline u32 BufferSizeForPort(int pad) const
+  {
+    if (m_pad_map[pad] <= 0)
+      return 0;
+
+    return std::max(m_minimum_buffer_size, m_players.at(m_pad_map.at(pad)).buffer);
+  }
+
+  // used for chat, not the best place for it
+  inline std::string FindPlayerPadName(const Player* player) const
+  {
+    for (int i = 0; i < 4; i++)
+    {
+      if (m_pad_map[i] == player->pid)
+        return " (port " + std::to_string(i + 1) + ")";
+    }
+
+    return "";
+  }
+
+  NetPlayUI* dialog = nullptr;
+  Player* local_player = nullptr;
 
   const PadMappingArray& GetPadMapping() const;
   const GBAConfigArray& GetGBAConfig() const;
   const PadMappingArray& GetWiimoteMapping() const;
 
-  void AdjustPadBufferSize(unsigned int size);
+  void AdjustMinimumPadBufferSize(unsigned int size);
 
   void SetWiiSyncData(std::unique_ptr<IOS::HLE::FS::FileSystem> fs, std::vector<u64> titles,
                       std::string redirect_folder);
@@ -221,7 +251,7 @@ class NetPlayClient : public Common::TraversalClientClient
   // try to keep in-flight to the other clients. In host input authority mode, this is how
   // many incoming input packets need to be queued up before the client starts
   // speeding up the game to drain the buffer.
-  unsigned int m_target_buffer_size = 20;
+  unsigned int m_minimum_buffer_size = 2;
   bool m_host_input_authority = false;
   PlayerId m_current_golfer = 1;
 
@@ -289,7 +319,8 @@ class NetPlayClient : public Common::TraversalClientClient
   void OnPadData(sf::Packet& packet);
   void OnPadHostData(sf::Packet& packet);
   void OnWiimoteData(sf::Packet& packet);
-  void OnPadBuffer(sf::Packet& packet);
+  void OnPadBufferMinimum(sf::Packet& packet);
+  void OnPadBufferPlayer(sf::Packet& packet);
   void OnHostInputAuthority(sf::Packet& packet);
   void OnGolfSwitch(sf::Packet& packet);
   void OnGolfPrepare(sf::Packet& packet);
@@ -357,4 +388,6 @@ void NetPlay_Enable(NetPlayClient* const np);
 void NetPlay_Disable();
 bool NetPlay_GetWiimoteData(const std::span<NetPlayClient::WiimoteDataBatchEntry>& entries);
 unsigned int NetPlay_GetLocalWiimoteForSlot(unsigned int slot);
+
+extern NetPlayClient* netplay_client;
 }  // namespace NetPlay

Source/Core/Core/NetPlayProto.h

@@ -148,9 +148,10 @@ enum class MessageID : u8
 
   PadData = 0x60,
   PadMapping = 0x61,
-  PadBuffer = 0x62,
+  PadBufferMinimum = 0x62,
   PadHostData = 0x63,
   GBAConfig = 0x64,
+  PadBufferPlayer = 0x66,
 
   WiimoteData = 0x70,
   WiimoteMapping = 0x71,

Source/Core/Core/NetPlayServer.cpp

@@ -168,7 +168,7 @@ NetPlayServer::NetPlayServer(const u16 port, const bool forward_port, NetPlayUI*
     is_connected = true;
     m_do_loop = true;
     m_thread = std::thread(&NetPlayServer::ThreadFunc, this);
-    m_target_buffer_size = 2;
+    m_minimum_buffer_size = 2;
     m_chunked_data_thread = std::thread(&NetPlayServer::ChunkedDataThreadFunc, this);
 
 #ifdef USE_UPNP
@@ -483,7 +483,7 @@ ConnectionError NetPlayServer::OnConnect(ENetPeer* incoming_connection, sf::Pack
   }
 
   if (!m_host_input_authority)
-    SendResponseToPlayer(new_player, MessageID::PadBuffer, m_target_buffer_size);
+    SendResponseToPlayer(new_player, MessageID::PadBufferMinimum, m_minimum_buffer_size);
 
   SendResponseToPlayer(new_player, MessageID::HostInputAuthority, m_host_input_authority);
 
@@ -668,19 +668,19 @@ void NetPlayServer::UpdateWiimoteMapping()
 }
 
 // called from ---GUI--- thread and ---NETPLAY--- thread
-void NetPlayServer::AdjustPadBufferSize(unsigned int size)
+void NetPlayServer::AdjustMinimumPadBufferSize(unsigned int size)
 {
   std::lock_guard lkg(m_crit.game);
 
-  m_target_buffer_size = size;
+  m_minimum_buffer_size = size;
 
   // not needed on clients with host input authority
   if (!m_host_input_authority)
   {
     // tell clients to change buffer size
     sf::Packet spac;
-    spac << MessageID::PadBuffer;
-    spac << m_target_buffer_size;
+    spac << MessageID::PadBufferMinimum;
+    spac << m_minimum_buffer_size;
 
     SendAsyncToClients(std::move(spac));
   }
@@ -701,7 +701,7 @@ void NetPlayServer::SetHostInputAuthority(const bool enable)
 
   // resend pad buffer to clients when disabled
   if (!m_host_input_authority)
-    AdjustPadBufferSize(m_target_buffer_size);
+    AdjustMinimumPadBufferSize(m_minimum_buffer_size);
 }
 
 void NetPlayServer::SendAsync(sf::Packet&& packet, const PlayerId pid, const u8 channel_id)
@@ -1567,7 +1567,7 @@ bool NetPlayServer::StartGame()
 
   // no change, just update with clients
   if (!m_host_input_authority)
-    AdjustPadBufferSize(m_target_buffer_size);
+    AdjustMinimumPadBufferSize(m_minimum_buffer_size);
 
   m_current_golfer = 1;
   m_pending_golfer = 0;

Source/Core/Core/NetPlayServer.h

@@ -21,6 +21,7 @@
 #include "Common/SPSCQueue.h"
 #include "Common/Timer.h"
 #include "Common/TraversalClient.h"
+#include "Core/NetPlayClient.h"
 #include "Core/NetPlayProto.h"
 #include "Core/SyncIdentifier.h"
 #include "InputCommon/GCPadStatus.h"
@@ -66,7 +67,7 @@ class NetPlayServer : public Common::TraversalClientClient
   PadMappingArray GetWiimoteMapping() const;
   void SetWiimoteMapping(const PadMappingArray& mappings);
 
-  void AdjustPadBufferSize(unsigned int size);
+  void AdjustMinimumPadBufferSize(unsigned int size);
   void SetHostInputAuthority(bool enable);
 
   void KickPlayer(PlayerId player);
@@ -92,6 +93,7 @@ class NetPlayServer : public Common::TraversalClientClient
     ENetPeer* socket = nullptr;
     u32 ping = 0;
     u32 current_game = 0;
+    unsigned int m_player_buffer_size = 0;
 
     Common::QoSSession qos_session;
 
@@ -170,7 +172,7 @@ class NetPlayServer : public Common::TraversalClientClient
   u32 m_ping_key = 0;
   bool m_update_pings = false;
   u32 m_current_game = 0;
-  unsigned int m_target_buffer_size = 0;
+  unsigned int m_minimum_buffer_size = 0;
   PadMappingArray m_pad_map;
   GBAConfigArray m_gba_config;
   PadMappingArray m_wiimote_map;

Source/Core/DolphinQt/MainWindow.cpp

@@ -1602,7 +1602,7 @@ bool MainWindow::NetPlayJoin()
   if (server)
   {
     server->SetHostInputAuthority(host_input_authority);
-    server->AdjustPadBufferSize(Config::Get(Config::NETPLAY_BUFFER_SIZE));
+    server->AdjustMinimumPadBufferSize(Config::Get(Config::NETPLAY_MINIMUM_BUFFER_SIZE));
   }
 
   // Create Client