dolphin/Source/Core/DolphinQt/NetPlay/NetPlayDialog.h

158 lines
4.6 KiB
C
Raw Normal View History

2017-07-21 20:48:21 +00:00
// Copyright 2017 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.
#pragma once
#include <QDialog>
#include <QMenuBar>
2017-07-21 20:48:21 +00:00
#include "Common/Lazy.h"
2017-07-21 20:48:21 +00:00
#include "Core/NetPlayClient.h"
#include "VideoCommon/OnScreenDisplay.h"
class ChunkedProgressDialog;
2017-07-21 20:48:21 +00:00
class MD5Dialog;
class GameListModel;
class PadMappingDialog;
class QCheckBox;
class QComboBox;
class QGridLayout;
class QGroupBox;
class QLabel;
class QLineEdit;
class QPushButton;
class QSpinBox;
2018-05-10 17:38:58 +00:00
class QSplitter;
2018-05-12 13:13:30 +00:00
class QTableWidget;
2017-07-21 20:48:21 +00:00
class QTextEdit;
class NetPlayDialog : public QDialog, public NetPlay::NetPlayUI
2017-07-21 20:48:21 +00:00
{
Q_OBJECT
public:
explicit NetPlayDialog(QWidget* parent = nullptr);
2018-05-10 17:38:58 +00:00
~NetPlayDialog();
2017-07-21 20:48:21 +00:00
void show(std::string nickname, bool use_traversal);
void reject() override;
// NetPlayUI methods
void BootGame(const std::string& filename) override;
void StopGame() override;
bool IsHosting() const override;
2017-07-21 20:48:21 +00:00
void Update() override;
void AppendChat(const std::string& msg) override;
void OnMsgChangeGame(const std::string& filename) override;
void OnMsgStartGame() override;
void OnMsgStopGame() override;
void OnMsgPowerButton() override;
2017-07-21 20:48:21 +00:00
void OnPadBufferChanged(u32 buffer) override;
NetPlay host input authority mode Currently, each player buffers their own inputs and sends them to the host. The host then relays those inputs to everyone else. Every player waits on inputs from all players to be buffered before continuing. What this means is all clients run in lockstep, and the total latency of inputs cannot be lower than the sum of the 2 highest client ping times in the game (in 3+ player sessions with people across the world, the latency can be very high). Host input authority mode changes it so players no longer buffer their own inputs, and only send them to the host. The host stores only the most recent input received from a player. The host then sends inputs for all pads at the SI poll interval, similar to the existing code. If a player sends inputs to slowly, their last received input is simply sent again. If they send too quickly, inputs are dropped. This means that the host has full control over what inputs are actually read by the game, hence the name of the mode. Also, because the rate at which inputs are received by SI is decoupled from the rate at which players are sending inputs, clients are no longer dependent on each other. They only care what the host is doing. This means that they can set their buffer individually based on their latency to the host, rather than the highest latency between any 2 players, allowing someone with lower ping to the host to have less latency than someone else. This is a catch to this: as a necessity of how the host's input sending works, the host has 0 latency. There isn't a good way to fix this, as input delay is now solely dependent on the real latency to the host's server. Having differing latency between players would be considered unfair for competitive play, but for casual play we don't really care. For this reason though, combined with the potential for a few inputs to be dropped on a bad connection, the old mode will remain and this new mode is entirely optional.
2018-08-24 08:17:18 +00:00
void OnHostInputAuthorityChanged(bool enabled) override;
2017-07-21 20:48:21 +00:00
void OnDesync(u32 frame, const std::string& player) override;
void OnConnectionLost() override;
void OnConnectionError(const std::string& message) override;
void OnTraversalError(TraversalClient::FailureReason error) override;
void OnTraversalStateChanged(TraversalClient::State state) override;
void OnGameStartAborted() override;
void OnGolferChanged(bool is_golfer, const std::string& golfer_name) override;
void OnIndexAdded(bool success, const std::string error) override;
void OnIndexRefreshFailed(const std::string error) override;
2017-07-21 20:48:21 +00:00
bool IsRecording() override;
std::string FindGame(const std::string& game) override;
std::shared_ptr<const UICommon::GameFile> FindGameFile(const std::string& game) override;
void SaveSettings();
2017-07-21 20:48:21 +00:00
void ShowMD5Dialog(const std::string& file_identifier) override;
void SetMD5Progress(int pid, int progress) override;
void SetMD5Result(int pid, const std::string& result) override;
void AbortMD5() override;
void ShowChunkedProgressDialog(const std::string& title, u64 data_size,
const std::vector<int>& players) override;
void HideChunkedProgressDialog() override;
void SetChunkedProgress(int pid, u64 progress) override;
2017-07-21 20:48:21 +00:00
signals:
void Boot(const QString& filename);
void Stop();
private:
void CreateChatLayout();
void CreatePlayersLayout();
void CreateMainLayout();
void ConnectWidgets();
void OnChat();
void OnStart();
void DisplayMessage(const QString& msg, const std::string& color,
int duration = OSD::Duration::NORMAL);
void ResetExternalIP();
void UpdateDiscordPresence();
2017-07-21 20:48:21 +00:00
void UpdateGUI();
void GameStatusChanged(bool running);
void SetOptionsEnabled(bool enabled);
2017-07-21 20:48:21 +00:00
void SetGame(const QString& game_path);
2019-03-17 00:09:06 +00:00
void SendMessage(const std::string& message);
2017-07-21 20:48:21 +00:00
// Chat
QGroupBox* m_chat_box;
QTextEdit* m_chat_edit;
QLineEdit* m_chat_type_edit;
QPushButton* m_chat_send_button;
// Players
QGroupBox* m_players_box;
QComboBox* m_room_box;
QLabel* m_hostcode_label;
QPushButton* m_hostcode_action_button;
2018-05-12 13:13:30 +00:00
QTableWidget* m_players_list;
2017-07-21 20:48:21 +00:00
QPushButton* m_kick_button;
QPushButton* m_assign_ports_button;
// Other
QMenuBar* m_menu_bar;
QMenu* m_data_menu;
QMenu* m_network_menu;
QMenu* m_md5_menu;
QMenu* m_other_menu;
2017-07-21 20:48:21 +00:00
QPushButton* m_game_button;
QPushButton* m_start_button;
QLabel* m_buffer_label;
QSpinBox* m_buffer_size_box;
QAction* m_save_sd_action;
QAction* m_load_wii_action;
QAction* m_sync_save_data_action;
QAction* m_sync_codes_action;
QAction* m_record_input_action;
QAction* m_reduce_polling_rate_action;
QAction* m_strict_settings_sync_action;
QAction* m_host_input_authority_action;
QAction* m_sync_all_wii_saves_action;
QAction* m_golf_mode_action;
2019-04-02 21:13:42 +00:00
QAction* m_golf_mode_overlay_action;
2017-07-21 20:48:21 +00:00
QPushButton* m_quit_button;
2018-05-10 17:38:58 +00:00
QSplitter* m_splitter;
2017-07-21 20:48:21 +00:00
QGridLayout* m_main_layout;
MD5Dialog* m_md5_dialog;
ChunkedProgressDialog* m_chunked_progress_dialog;
2017-07-21 20:48:21 +00:00
PadMappingDialog* m_pad_mapping;
std::string m_current_game;
Common::Lazy<std::string> m_external_ip_address;
2017-07-21 20:48:21 +00:00
std::string m_nickname;
GameListModel* m_game_list_model = nullptr;
bool m_use_traversal = false;
bool m_is_copy_button_retry = false;
2018-07-03 23:02:13 +00:00
bool m_got_stop_request = true;
int m_buffer_size = 0;
int m_player_count = 0;
int m_old_player_count = 0;
NetPlay host input authority mode Currently, each player buffers their own inputs and sends them to the host. The host then relays those inputs to everyone else. Every player waits on inputs from all players to be buffered before continuing. What this means is all clients run in lockstep, and the total latency of inputs cannot be lower than the sum of the 2 highest client ping times in the game (in 3+ player sessions with people across the world, the latency can be very high). Host input authority mode changes it so players no longer buffer their own inputs, and only send them to the host. The host stores only the most recent input received from a player. The host then sends inputs for all pads at the SI poll interval, similar to the existing code. If a player sends inputs to slowly, their last received input is simply sent again. If they send too quickly, inputs are dropped. This means that the host has full control over what inputs are actually read by the game, hence the name of the mode. Also, because the rate at which inputs are received by SI is decoupled from the rate at which players are sending inputs, clients are no longer dependent on each other. They only care what the host is doing. This means that they can set their buffer individually based on their latency to the host, rather than the highest latency between any 2 players, allowing someone with lower ping to the host to have less latency than someone else. This is a catch to this: as a necessity of how the host's input sending works, the host has 0 latency. There isn't a good way to fix this, as input delay is now solely dependent on the real latency to the host's server. Having differing latency between players would be considered unfair for competitive play, but for casual play we don't really care. For this reason though, combined with the potential for a few inputs to be dropped on a bad connection, the old mode will remain and this new mode is entirely optional.
2018-08-24 08:17:18 +00:00
bool m_host_input_authority = false;
2017-07-21 20:48:21 +00:00
};